Microservices Practitioner Summit Jan '15 - Microservice Ecosystems At Scale - Randy Shoup

Developing integration microservices using CI/CD with apache camel, open shift, fabric8.io, jenkins, et al.

We consider a microservices architecture to achieve an end goal, not because it's "the cool thing to do". Every organization looking to adopt this architecture must realize (and adhere) to a set of foundational principles. Guided by those principles, we can correctly choose the technology to help support a microservices architecture and meet our end goals. This talk explains those core principles and gives you the tools needed for your microservices journey.

The document discusses moving from a monolithic architecture to microservices. A monolithic application can be difficult to maintain, upgrade, and scale as it grows in size. Microservices break an application into smaller, independent services that can be developed and deployed independently. This improves maintainability, scalability, and allows incremental upgrades. However, microservices come with additional complexity from managing more distributed components and potential performance impacts from additional network calls. The document provides design considerations and best practices for implementing microservices, such as domain-driven design and event-driven asynchronous communication between services.

The document discusses continuous delivery of integration applications using JBoss Fuse and OpenShift. It covers the cost of change in software development, how JBoss Fuse can help with integration challenges, and how OpenShift enables continuous delivery through automation and a developer self-service platform as a service model. The presentation demonstrates how to build a continuous delivery pipeline using tools like Git, Jenkins, Fabric8, and OpenShift to deploy and test applications.

Spring Cloud/Netflix OSS way of building microservices on Kubernetes -- preso from Spring One Platform 2016

This document discusses extensibility features for ADF applications. It describes how extensions can customize pages, navigation, menus, toolbars, metadata, and more using JSON configuration files. Extensions can register custom components, routes, and actions. Rules are JavaScript functions that can access application state and be composed from other rules. Extensions are distributed as standard Angular libraries and installed via commands. The core @alfresco/adf-extensions library provides services to support extensibility. Future plans include more extension points, validation tools, and automatic installation of extensions.

Building applications for the IaaS Cloud is easy, right? "Sure, no problem - just lift and shift!" all the Cloud vendors shout in unison. However, the reality of building and deploying Cloud applications can often be different. This talk will introduce lessons learnt from the trenches during two years of designing and implementing cloud-based Java applications, which we have codified into our Cloud developer’s 'DHARMA' rules; Documented (just enough); Highly cohesive/loosely coupled (all the way down); Automated from code commit to cloud; Resource aware; Monitored thoroughly; and Antifragile. We will look at these lessons from both a theoretic and practical perspective using a real-world case study from Instant Access Technologies (IAT) Ltd. IAT recently evolved their epoints.com(http://epoints.com/) customer loyalty platform from a monolithic Java application deployed into a data centre on a 'big bang' schedule, to a platform of loosely-coupled JVM-based components, all being continuously deployed into the AWS IaaS Cloud

1) Interaxo is a SaaS application for managing building projects that uses Alfresco and has grown to over 1,000 tenants and 50,000 users. 2) The company transitioned to a cloud native architecture using Kubernetes, Docker, and AWS to allow for better scalability, automation, and continuous delivery in order to keep up with growth and gain strategic advantages. 3) Some guiding principles of the cloud native transition included treating their datacenter as a cloud provider, adopting Kubernetes gradually through proof of concepts, and using GitOps over complex Jenkins pipelines for configuration and deployments.

From a talk at the SF CTO Summit 2017 (https://www.ctoconnection.com/summits/sf2017), these slides cover the speaker's experience at Stitch Fix with managing data in a microservices environment. Areas include: * Breaking up a monolithic database into services * Using events as a first-class part of your architecture * Sharing data among microservices * Handling "joins" among microservices * Simulating "transactions" among microservices using the Saga pattern

This document discusses microservices and provides an overview of related concepts. It begins with definitions of microservices and comparisons to monolithic applications. Key features of microservices like independent processes communicating over HTTP are outlined. The document then covers reasons for using HTTP, REST, and JSON in microservice architectures. An example online shopping application is used to illustrate how it could be decomposed into microservices. Challenges of monolithic applications are contrasted with advantages of the microservice approach. The document concludes with a summary of Spring Cloud which provides tools to help implement microservices patterns.

The document discusses avoiding distributed monoliths by not coupling systems with binary dependencies like shared libraries and network clients. It recommends using contracts and protocols instead of shared libraries to allow for independence between services. Common examples of binary coupling that should be avoided are shared libraries for routing, discovery, logging etc. Coupling systems in this way leads to lost benefits like inability to use different languages, platforms or concurrency models for individual services.

Discover tips and tools that will help you to keep your Alfresco environment in shape. Most of the best tools are free or Open Source, and this presentation will guide you through the steps to improve the performance of your system.

KnockoutJS is a JavaScript library that provides declarative bindings between a data model and UI. It exposes the MVVM pattern, separating model, view, and view model concerns. Two-way data binding automatically synchronizes data between the model and view. Observables notify of changes and detect dependencies, enabling two-way binding between UI elements and the JavaScript view model. KnockoutJS is lightweight, fully documented, and suitable for building small to medium single-page applications.

The document discusses the evolution of application networking from individual microservices libraries to shared proxies like Envoy and service meshes like Istio. It notes that as applications adopt microservices architectures, many common concerns around distributed systems must be addressed, such as service discovery, load balancing, and fault tolerance. Initially, different frameworks offered individual libraries to handle these issues, but this led to inconsistencies and increased complexity. Envoy proxy and the Istio service mesh aim to provide a standardized and shared way to address these cross-cutting distributed system concerns for all services regardless of language or framework.

Fundamental and Practice. Explain about microservices characters and pattern. And also how to be good build microservices. And also additional the scale cube and CAP theory.

This deck is about Microservices Architecture and why do we need it, architecture patterns which need to be followed during Microservices development, and about few tricky questions like API Versioning and Decomposition Recipes

The document discusses microservices, DevOps, and containers. It introduces the speaker, Christian Posta, and his background working with microservices at a large company. It then asks questions about the organization's motivations for considering microservices and discusses challenges with keeping up with change. The document promotes OpenShift and Fabric8 as open-source platforms that can help automate build, deployment, and integration processes in a cloud-native way. It highlights features like CI/CD, management tools, and libraries to simplify developing microservices applications.

Over time, almost all large, well-known web sites have evolved their architectures from an early monolithic application to a loosely-coupled ecosystem of polyglot microservices. While first-order goals are almost always driven by the needs of scalability and velocity, this evolution also produces second-order effects on the organization as well. This session will discuss modern service architectures at scale, using specific examples from both Google and eBay. It covers some interesting -- and perhaps nonintuitive -- lessons learned in building and operating these sites. It concludes with a number of experience-based recommendations for other smaller organizations evolving to -- and sustaining -- an effective service ecosystem.