Developing applications with a microservice architecture (SVforum, microservi...
Here is the version of my microservices talk that that I gave on September 17th at the SVforum Cloud SIG/Microservices meetup.
To learn more see http://microservices.io and http://plainoldobjects.com
The introduction covers the following
1. What are Microservices and why should be use this paradigm?
2. 12 factor apps and how Microservices make it easier to create them
3. Characteristics of Microservices
Note: Please download the slides to view animations.
Microservice architecture is gaining popularity in the community, as large scale websites, such as Netflix and Amazon, adopted this paradigm and achieved better scalability. In this talk, we will cover issues with monolithic approach, how microservice architecture addresses those issues, and how it works in the real world.
This document discusses designing microservices. It covers identifying service boundaries by analyzing business domains. Key considerations for service design include granularity, managing dependencies, capturing domain knowledge, and exposing interfaces. Data modeling challenges with microservices like eventual consistency are also addressed. The document provides an overview of implementing microservices on platforms like Service Fabric and container technologies.
Enterprises are increasingly adopting DevOps. Docker adoption has surged to 35%, taking the lead over Chef and Puppet which at 28% each. To get the most out of the synergy between DevOps and containers you need to adopt container-native architecture for application development. This slide deck explores the importance of having container-native architecture in your enterprise and WSO2’s roadmap for it.
Modern Software Architecture - Cloud Scale Computing
The document provides an overview of modern cloud architecture. It discusses key cloud concepts like Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS). It also covers architectural considerations for cloud applications like multi-tenancy, load balancing, scaling, security, monitoring, and metering. Microservices architecture and containerization are introduced as approaches for building applications for the cloud. Data-intensive architectures like lambda architecture are also summarized.
The document provides an overview of modern cloud application architecture compared to traditional on-premises architecture. It discusses key aspects of the software development process including analyzing business requirements, choosing an architecture style, and applying design patterns and best practices. Various architecture styles are described such as microservices, event-driven, and big data architectures. Common cloud design patterns are also discussed.
Microservice architecture (MSA) is fast becoming a popular architecture pattern in today’s agile enterprises. Its iterative architecture and development methodologies are attracting the interest of architects who need continuous delivery to fulfill business needs. But, is every characteristic of MSA new or even pragmatic? Can MSA alone help you solve your enterprise challenges? This session will explore how middleware plays a key role in successful MSA-based implementations.
Merging micrservices architecture with SOA Practices
The document discusses merging microservices architecture with SOA practices. It begins with background on the presenter and an agenda that includes defining and sizing microservices, DevOps practices for deployment, and avoiding fragility. Microservices are defined as small, independent, and process-isolated services. The document explores benefits and challenges of microservices, including proper sizing of services and managing dependencies. It provides examples of DevOps practices for loose coupling like service isolation and separate databases. The conclusion emphasizes starting small and reconciling SOA and microservices when sharing capabilities, APIs, and building applications.
- Microservices advocate creating a system from small, isolated services that each own their data and are independently scalable and resilient. They are inspired by biological cells that are small, single-purpose, and work together through messaging.
- The system is divided using a divide and conquer approach, decomposing it into discrete subsystems that communicate over well-defined protocols. Each microservice focuses on a single business capability and owns its own data and behavior.
- Microservices communicate asynchronously through APIs and events to maintain independence and isolation, which enables continuous delivery, failure resilience, and independent scaling of each service.
Microservices: Where do they fit within a rapidly evolving integration archit...
Do microservices force us to look differently at the way we lay down and evolve our integration architecture, or are they purely about how we build applications? Are microservices a new concept, or an evolution of the many ideas that came before them? What is the relationship between microservices and other key initiatives such as APIs, SOA, and Agile. In this session, we will unpick what microservices really are, and indeed what they are not. We will consider whether there is something unique about this particular point time in technology that has enables microservice concepts to take hold. Finally, we will look at if, when, where and how an enterprise can take on the benefits of microservices, and what products and technologies are applicable for that journey.
[WSO2Con EU 2017] How a Large Organization Weighted on a WSO2 Integration Pla...
This slide deck explores in-depth how enioka Haute Couture designed and built an integration platform around WSO2 ESB to expose internal services to external applications (SaaS, external partners); and how this became a central component of the collaboration between every actor of integration projects.
This document discusses microservices architecture and related concepts. It begins with an overview of microservices compared to earlier SOA approaches. Key aspects of microservices covered include developing single applications as independent services, common misconceptions, principles like single responsibility, and defining appropriate service boundaries. The document also discusses messaging approaches in microservices including REST, gRPC, and asynchronous messaging. Other sections cover organizing microservices, deployment, security, data management, governance, bridging monolithic and microservice systems, and implementing a service mesh.
Slides der Präsentation von Simeon Bosshard, Citrix, am Citrix Day 2014 von Digicomp.
Das HTML 5 GUI im Release 10.5 des NetScaler ist eine Neuerung, aber nicht die einzige. Erfahren Sie mehr über die wichtigsten Änderungen wie etwa MobileStream, Cisco RISE und ACI Integration sowie die Erweiterungen im Authentication-Bereich. Natürlich kommen die Neuerungen in den Core-Bereichen Loadbalancing, SSL Offloading etc. ebenfalls nicht zu kurz.
Business and IT agility through DevOps and microservice architecture powered ...
IT needs to run in production in order to generate business value. DevOps is among other things a way of thinking focusing on production software. A business application requires a tailor made platform to generate business value. The combination of application and its platform is a DevOps product. The DevOps team has full responsibility for that product through its entire lifecycle.
The microservices architecture promises flexibility, scalability, and optimal use of compute resources. Via independent components with well-defined scope and responsibility, interface, and ownership that are evolved and managed in an automated DevOps process, this architecture leverages current technologies and hard-learned insights from past decades.
This session defines the objectives of Business with IT, of microservices and DevOps and introduces Containers and the container platform Kubernetes as crucial ingredients for making DevOps happen.
Microservices-based architectures are in vogue. Over the last couple of years, we have learned how thought leaders implement them, and it seems like every other week we hear about how containers and platform-as-a-service offerings make them ultimately happen.
Tech Talent Night Copenhagen 11/22/17
https://greenticket.dk/techtalentnightcph
2013.07.05 [IBM] Cloud Ecosystem Forum - Atelier Directions Techniques
- The document discusses IBM's strategy around open cloud, OpenStack, DevOps, and orchestration. It highlights several of IBM's offerings related to these areas including SmartCloud products, UrbanCode, and IBM's contributions to OpenStack.
- IBM is a major contributor to OpenStack and bases much of its cloud software and services on an open cloud architecture centered around OpenStack.
- DevOps, workload orchestration, service orchestration, and technical orchestration are discussed as ways to automate the lifecycle of applications and services across environments.
- Patterns for deploying virtual applications from infrastructure-as-a-service to platform-as-a-service are described.
The document discusses strategies for evolving monolithic applications into microservice architectures. It notes that modern software needs to meet increasing demands around release frequency, developer velocity, and infrastructure costs. While classical architectures based on monoliths and service-oriented architectures were effective, they no longer address today's challenges. The document then introduces microservices as an alternative, describing characteristics like independent deployability, language/data agnosticism, and process isolation. It acknowledges that while building individual microservices is straightforward, the difficult part is designing the overall system architecture and operational capabilities required to manage many interconnected microservices. Lagom is presented as one framework that can help implement reactive microservices on the JVM.
Presentation on the current state of cloud computing and the role that open source, containers and microservices are playing in the cloud.
Presented to Florida Linux Users Exchange on April 9th, 2015
Modernizing Applications with Microservices and DC/OS (Lightbend/Mesosphere c...
**Featuring Aaron Williams, Head of Advocacy at Mesosphere, Inc. and Markus Eisele, Developer Advocate at Lightbend, Inc.**
The traditional architecture that enterprises run their businesses on has typically been delivered as monolithic applications running in a virtualized, on-premise infrastructure. Public and private cloud technologies have changed everything, but if the applications are not designed, or re-designed, appropriately, then it is impossible to take advantage of the advances in both distributed application services and hybrid infrastructure. Consequently, enterprise architects are looking to microservices-based architectures as a means to modernize their legacy applications.
This webinar with Lightbend and partner Mesosphere will introduce a new framework specifically designed to help developers modernize legacy Java EE applications into systems of microservices and then discuss exactly what is required to run these distributed systems at enterprise scale.
This document provides an introduction and overview of containers, Kubernetes, IBM Container Service, and IBM Cloud Private. It discusses how microservices architectures break monolithic applications into smaller, independently developed services. Containers are presented as a standard way to package applications to move between environments. Kubernetes is introduced as an open-source system for automating deployment and management of containerized applications. IBM Cloud Container Service and IBM Cloud Private are then overviewed as platforms that combine Docker and Kubernetes to enable deployment of containerized applications on IBM Cloud infrastructure.
Docker concepts and microservices architecture are discussed. Key points include:
- Microservices architecture involves breaking applications into small, independent services that communicate over well-defined APIs. Each service runs in its own process and communicates through lightweight mechanisms like REST/HTTP.
- Docker allows packaging and running applications securely isolated in lightweight containers from their dependencies and libraries. Docker images are used to launch containers which appear as isolated Linux systems running on the host.
- Common Docker commands demonstrated include pulling public images, running interactive containers, building custom images with Dockerfiles, and publishing images to Docker Hub registry.
This document discusses cloud native architectures and microservices. It introduces the speaker and covers topics like how fast software delivery requires decoupling services, using containers and Kubernetes for deployment, and using Apache Camel for integration between microservices. It also discusses using OpenShift and Fuse Integration Services on OpenShift to develop and deploy microservices in a cloud native way.
Presentation for Dutch Microsoft TechDays 2015 with Marcel de Vries:
During this session we will take a look at how to realize a Microservices architecture (MSA) using the latest Microsoft technologies available. We will discuss some fundamental theories behind MSA and show you how this can actually be realized with Microsoft technologies such as Azure Service Fabric. This session is a real must-see for any developer that wants to stay ahead of the curve in modern architectures.
Architecture: When, how, and if to Adopt Microservices
Microservices are not for everyone! If you're a small shop, a monolith provides a great amount of value and reduces the complexities involved. However as your company grows, this monolith becomes more difficult to maintain. We’ll look at how microservices allow you to easily deploy and debug atomic pieces of infrastructure which allows for increased velocity in reliable, tested, and consistent deploys. We’ll look into key metrics you can use to identify the right time to begin the transition from monolith to microservices.
This is the slide deck for the DFW Azure User Group meetup of 18 July 2017, presented by Doug Vanderweide and discussing Azure's services that support a microservices architecture.
node.js and Containers: Dispatches from the Frontier
This document discusses node.js and containers for microservices architectures. It describes how microservices architectures break large monolithic applications into many smaller independent services. Node.js is well-suited for microservices due to its lightweight footprint and asynchronous nature. Containers provide an efficient way to run many independent services on a single machine by virtualizing at the operating system level. The document outlines lessons learned from rewriting a cloud orchestration system called SmartDataCenter using a microservices and container-based architecture.
The document discusses microservices and how Azure supports the microservices architecture for modern applications. It defines microservices and service-oriented architecture as an approach to building applications as independent, interoperable services. It then describes the various Azure PaaS options for hosting microservices, such as App Service, Functions, and Service Fabric. It also covers supporting Azure services for state management, caching, storage, and monitoring microservices applications. Finally, it provides an example topology of a photo sharing solution built with multiple Azure microservices.
Microservices and serverless for MegaStartups - DLD TLV 2017
Boaz Ziniman, a technical evangelist at AWS, presented on microservices and serverless architectures for mega startups. He discussed how monolithic architectures can limit agility and discussed how microservices help address these issues by decomposing applications into independently deployable services. He then explained how serverless computing removes the need to manage servers by allowing developers to run code without provisioning or managing servers. Examples of serverless offerings from AWS like AWS Lambda were provided. Common use cases for microservices and serverless architectures like web applications, backends, and data processing were also outlined.
The document discusses microservices and provides information on:
- The benefits of microservices including faster time to market, lower deployment costs, and more revenue opportunities.
- What defines a microservice such as being independently deployable and scalable.
- Differences between monolithic and microservice architectures.
- Moving applications to the cloud and refactoring monolithic applications into microservices.
- Tools for building microservices including Azure Service Fabric and serverless/Functions.
- Best practices for developing, deploying, and managing microservices.
Just a JSON parser plus a small subset of JSONPath.
Small (currently 4200 lines of code)
Very fast, uses an index overlay from the ground up.
Does not do JavaBean serialization but can serialize into basic Java types and can map to Java classes and Java records.
This talk was done in Feb 2020. Sergey and I co-presented at CTO Forum on Microservices and Service Mesh (how they relate, requirements, goals, best practices and how DevOps and Agile has had convergence in the set of features for Service Mesh and gateways around observability, feature flags, etc.)
Early Draft: Service Mesh allows developers to focus on business logic while the crosscutting network data layer code is handled by the Service Mesh. This is a boon because this code can be tricky to implement and hard to test all of the edge cases. Service Mesh takes this a few steps further than AOP or Servlet Filters or custom language-specific frameworks because it works regardless of the underlying programming language being used which is great for polyglot development shops. Thus standardizing how these layers work, while allowing teams to pick the best tools or languages for the job at hand. Kubernetes and Istio Service Mesh automate best practices for DevSecOps needs like: failover, scale-out, scalability, health checks, circuit breakers, rate limiters, metrics, observability, avoiding cascading failure, disaster recovery, and traffic routing; supporting CI/CD and microservices architecture.
Istio’s ability to automate and maintaining zero trust networks is its most important feature. In the age of high-profile data breaches, security is paramount. Companies want to avoid major brand issues that impact the bottom line and shrink market capitalization in an instant. Istio allows a standard way to do mTLS and auto certificate rotation which helps prevent a breach and limits the blast radius if a breach occurs. Istio also takes the concern of mTLS from microservices deployments and makes it easy to use taking the burden off of application developers.
This document summarizes key points from the book Accelerate about achieving high performance through DevOps practices. It discusses that high performing teams deploy code more frequently with shorter lead times and change fail rates. They use trunk-based development and loosely coupled architectures. Implementing continuous delivery, monitoring, and a lean approach improves software delivery, quality, and reduces burnout. Culture capabilities like learning and collaboration also impact performance. Overall, DevOps practices can double organizational metrics like profitability and productivity. The document advocates transforming through understanding these practices.
Covers how we built a set of high-speed reactive microservices and maximized cloud/hardware costs while meeting objectives in resilience and scalability. Talks about Akka, Kafka, QBit, in-memory computing, from a practitioners point of view. Based on the talks delivered by Geoff Chandler, Jason Daniel, and Rick Hightower at JavaOne 2016 and SF Fintech at Scale 2017, but updated.
Reactive Java: Promises and Streams with Reakt (JavaOne Talk 2016)
see labs at https://github.com/advantageous/j1-talks-2016
Import based on PPT so there is more notes. This is from our JavaOne Talk 2016 on Reakt, reactive Java programming with promises, circuit breakers, and streams. Reakt is a reactive Java lib that provides promises, streams, and a reactor to handle asynchronous call coordination. It was influenced by the design of promises in ES6. You want to async-call serviceA and then serviceB, take the results of serviceA and serviceB, and then call serviceC. Then, based on the results of call C, call D or E and then return the results to the original caller. Calls to A, B, C, D, and E are all async calls, and none should take longer than 10 seconds. If they do, then return a timeout to the original caller. The whole async call sequence should time out in 20 seconds if it does not complete and should also check for circuit breakers and provide back pressure feedback so the system does not have cascading failures. Learn more in this session.
Reactive Java: Promises and Streams with Reakt (JavaOne talk 2016)
see labs at https://github.com/advantageous/j1-talks-2016
Import based on PDF. This is from our JavaOne Talk 2016 on Reakt, reactive Java programming with promises, circuit breakers, and streams. Reakt is a reactive Java lib that provides promises, streams, and a reactor to handle asynchronous call coordination. It was influenced by the design of promises in ES6. You want to async-call serviceA and then serviceB, take the results of serviceA and serviceB, and then call serviceC. Then, based on the results of call C, call D or E and then return the results to the original caller. Calls to A, B, C, D, and E are all async calls, and none should take longer than 10 seconds. If they do, then return a timeout to the original caller. The whole async call sequence should time out in 20 seconds if it does not complete and should also check for circuit breakers and provide back pressure feedback so the system does not have cascading failures. Learn more in this session.
High-Speed Reactive Microservices - trials and tribulations
Covers how we built a set of high-speed reactive microservices and maximized cloud/hardware costs while meeting objectives in resilience and scalability. This has more notes attached as it is based on the ppt not the PDF.
High-speed reactive microservices (HSRM) are microservices that are in-memory, non-blocking, own their data through leasing, and use streams and batching. They provide advantages like lower costs, ability to handle more traffic with fewer resources, and cohesive codebases. The example service described handles 30k recommendations/second on a single thread through batching, streaming, and data faulting. The document discusses attributes of HSRM like single writer rules and service stores, and related concepts like reactive programming, streams, and service sharding.
Netty Notes Part 3 - Channel Pipeline and EventLoops
Learning more about Netty helps me understand Vert.x better. Netty in Action is a great book. The threading model of Netty is very important to understanding event loops and reactive programming.
This document provides notes on Netty Part 2 focusing on transports and buffers. It discusses the different Netty transport options including NIO, epoll, and OIO. It explains that Netty provides a common interface for different implementations. The document also covers Netty buffers including ByteBuf, direct vs array-backed buffers, composite buffers, and buffer pooling. It emphasizes that performance gains come from reducing byte copies and buffer allocation.
Comparing the speed of RPC calls over WebScoket Microservices versus REST based microservices. Using wrk, QBit, and examples in Java we show how much faster WebSocket is for doing RPC service calls.
Consul: Microservice Enabling Microservices and Reactive Programming
Consul is a service discovery system that provides a microservice style interface to services, service topology and service health.
With service discovery you can look up services which are organized in the topology of your datacenters. Consul uses client agents and RAFT to provide a consistent view of services. Consul provides a consistent view of configuration as well also using RAFT. Consul provides a microservice interface to a replicated view of your service topology and its configuration. Consul can monitor and change services topology based on health of individual nodes.
Consul provides scalable distributed health checks. Consul only does minimal datacenter to datacenter communication so each datacenter has its own Consul cluster. Consul provides a domain model for managing topology of datacenters, server nodes, and services running on server nodes along with their configuration and current health status.
Consul is like combining the features of a DNS server plus Consistent Key/Value Store like etcd plus features of ZooKeeper for service discovery, and health monitoring like Nagios but all rolled up into a consistent system. Essentially, Consul is all the bits you need to have a coherent domain service model available to provide service discovery, health and replicated config, service topology and health status. Consul also provides a nice REST interface and Web UI to see your service topology and distributed service config.
Consul organizes your services in a Catalog called the Service Catalog and then provides a DNS and REST/HTTP/JSON interface to it.
To use Consul you start up an agent process. The Consul agent process is a long running daemon on every member of Consul cluster. The agent process can be run in server mode or client mode. Consul agent clients would run on every physical server or OS virtual machine (if that makes more sense). Client runs on server hosting services. The clients use gossip and RPC calls to stay in sync with Consul.
A client, consul agent running in client mode, forwards request to a server, consul agent running in server mode. Clients are mostly stateless. The client does LAN gossip to the server nodes to communicate changes.
A server, consul agent running in server mode, is like a client agent but with more tasks. The consul servers use the RAFT quorum mechanism to see who is the leader. The consul servers maintain cluster state like the Service Catalog. The leader manages a consistent view of config key/value pairs, and service health and topology. Consul servers also handle WAN gossip to other datacenters. Consul server nodes forwards queries to leader, and forward queries to other datacenters.
A Datacenter is fairly obvious. It is anything that allows for fast communication between nodes, with as few or no hops, little or no routing, and in short: high speed communication. This could be an Amazon EC2 availability zone, a networking environment like a subnet, or any private, low latency, high
[WSO2Con EU 2017] Writing Microservices Using MSF4JWSO2
This document provides an overview of WSO2 MSF4J, a lightweight Java framework for building microservices. It describes MSF4J's annotation-based programming model, support for Spring configuration, serverless execution, streaming, security, monitoring, and compares it to Spring Boot. MSF4J provides a simple way to define microservice APIs, built-in metrics and analytics, fast startup times, and low memory usage.
#JaxLondon keynote: Developing applications with a microservice architectureChris Richardson
The document summarizes Chris Richardson's presentation on developing applications with a microservice architecture. The presentation discusses how decomposing monolithic applications into microservices improves deployability, scalability, and simplifies adopting new technologies. It covers the benefits of microservices, including improved fault isolation, reduced commitment to technology stacks, and easier scaling of development. It also discusses challenges like complexity in developing, testing, and operating distributed systems.
A brief intro to microservice patters and strategies.
This is a presentation from the series "by Developer for Developers" powered by eSolutions Grup.
You can find the practical example at https://github.com/eSolutionsGrup/microshop
Developing applications with a microservice architecture (SVforum, microservi...Chris Richardson
Here is the version of my microservices talk that that I gave on September 17th at the SVforum Cloud SIG/Microservices meetup.
To learn more see http://microservices.io and http://plainoldobjects.com
The introduction covers the following
1. What are Microservices and why should be use this paradigm?
2. 12 factor apps and how Microservices make it easier to create them
3. Characteristics of Microservices
Note: Please download the slides to view animations.
Microservice architecture is gaining popularity in the community, as large scale websites, such as Netflix and Amazon, adopted this paradigm and achieved better scalability. In this talk, we will cover issues with monolithic approach, how microservice architecture addresses those issues, and how it works in the real world.
This document discusses designing microservices. It covers identifying service boundaries by analyzing business domains. Key considerations for service design include granularity, managing dependencies, capturing domain knowledge, and exposing interfaces. Data modeling challenges with microservices like eventual consistency are also addressed. The document provides an overview of implementing microservices on platforms like Service Fabric and container technologies.
[WSO2Con EU 2017] Container-native ArchitectureWSO2
Enterprises are increasingly adopting DevOps. Docker adoption has surged to 35%, taking the lead over Chef and Puppet which at 28% each. To get the most out of the synergy between DevOps and containers you need to adopt container-native architecture for application development. This slide deck explores the importance of having container-native architecture in your enterprise and WSO2’s roadmap for it.
The document provides an overview of modern cloud architecture. It discusses key cloud concepts like Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS). It also covers architectural considerations for cloud applications like multi-tenancy, load balancing, scaling, security, monitoring, and metering. Microservices architecture and containerization are introduced as approaches for building applications for the cloud. Data-intensive architectures like lambda architecture are also summarized.
The document provides an overview of modern cloud application architecture compared to traditional on-premises architecture. It discusses key aspects of the software development process including analyzing business requirements, choosing an architecture style, and applying design patterns and best practices. Various architecture styles are described such as microservices, event-driven, and big data architectures. Common cloud design patterns are also discussed.
[WSO2Con EU 2017] Microservices for EnterprisesWSO2
Microservice architecture (MSA) is fast becoming a popular architecture pattern in today’s agile enterprises. Its iterative architecture and development methodologies are attracting the interest of architects who need continuous delivery to fulfill business needs. But, is every characteristic of MSA new or even pragmatic? Can MSA alone help you solve your enterprise challenges? This session will explore how middleware plays a key role in successful MSA-based implementations.
Merging micrservices architecture with SOA Practices WSO2
The document discusses merging microservices architecture with SOA practices. It begins with background on the presenter and an agenda that includes defining and sizing microservices, DevOps practices for deployment, and avoiding fragility. Microservices are defined as small, independent, and process-isolated services. The document explores benefits and challenges of microservices, including proper sizing of services and managing dependencies. It provides examples of DevOps practices for loose coupling like service isolation and separate databases. The conclusion emphasizes starting small and reconciling SOA and microservices when sharing capabilities, APIs, and building applications.
- Microservices advocate creating a system from small, isolated services that each own their data and are independently scalable and resilient. They are inspired by biological cells that are small, single-purpose, and work together through messaging.
- The system is divided using a divide and conquer approach, decomposing it into discrete subsystems that communicate over well-defined protocols. Each microservice focuses on a single business capability and owns its own data and behavior.
- Microservices communicate asynchronously through APIs and events to maintain independence and isolation, which enables continuous delivery, failure resilience, and independent scaling of each service.
Microservices: Where do they fit within a rapidly evolving integration archit...Kim Clark
Do microservices force us to look differently at the way we lay down and evolve our integration architecture, or are they purely about how we build applications? Are microservices a new concept, or an evolution of the many ideas that came before them? What is the relationship between microservices and other key initiatives such as APIs, SOA, and Agile. In this session, we will unpick what microservices really are, and indeed what they are not. We will consider whether there is something unique about this particular point time in technology that has enables microservice concepts to take hold. Finally, we will look at if, when, where and how an enterprise can take on the benefits of microservices, and what products and technologies are applicable for that journey.
[WSO2Con EU 2017] How a Large Organization Weighted on a WSO2 Integration Pla...WSO2
This slide deck explores in-depth how enioka Haute Couture designed and built an integration platform around WSO2 ESB to expose internal services to external applications (SaaS, external partners); and how this became a central component of the collaboration between every actor of integration projects.
This document discusses microservices architecture and related concepts. It begins with an overview of microservices compared to earlier SOA approaches. Key aspects of microservices covered include developing single applications as independent services, common misconceptions, principles like single responsibility, and defining appropriate service boundaries. The document also discusses messaging approaches in microservices including REST, gRPC, and asynchronous messaging. Other sections cover organizing microservices, deployment, security, data management, governance, bridging monolithic and microservice systems, and implementing a service mesh.
Slides der Präsentation von Simeon Bosshard, Citrix, am Citrix Day 2014 von Digicomp.
Das HTML 5 GUI im Release 10.5 des NetScaler ist eine Neuerung, aber nicht die einzige. Erfahren Sie mehr über die wichtigsten Änderungen wie etwa MobileStream, Cisco RISE und ACI Integration sowie die Erweiterungen im Authentication-Bereich. Natürlich kommen die Neuerungen in den Core-Bereichen Loadbalancing, SSL Offloading etc. ebenfalls nicht zu kurz.
Business and IT agility through DevOps and microservice architecture powered ...Lucas Jellema
IT needs to run in production in order to generate business value. DevOps is among other things a way of thinking focusing on production software. A business application requires a tailor made platform to generate business value. The combination of application and its platform is a DevOps product. The DevOps team has full responsibility for that product through its entire lifecycle.
The microservices architecture promises flexibility, scalability, and optimal use of compute resources. Via independent components with well-defined scope and responsibility, interface, and ownership that are evolved and managed in an automated DevOps process, this architecture leverages current technologies and hard-learned insights from past decades.
This session defines the objectives of Business with IT, of microservices and DevOps and introduces Containers and the container platform Kubernetes as crucial ingredients for making DevOps happen.
Stay productive while slicing up the monolithMarkus Eisele
Microservices-based architectures are in vogue. Over the last couple of years, we have learned how thought leaders implement them, and it seems like every other week we hear about how containers and platform-as-a-service offerings make them ultimately happen.
Tech Talent Night Copenhagen 11/22/17
https://greenticket.dk/techtalentnightcph
- The document discusses IBM's strategy around open cloud, OpenStack, DevOps, and orchestration. It highlights several of IBM's offerings related to these areas including SmartCloud products, UrbanCode, and IBM's contributions to OpenStack.
- IBM is a major contributor to OpenStack and bases much of its cloud software and services on an open cloud architecture centered around OpenStack.
- DevOps, workload orchestration, service orchestration, and technical orchestration are discussed as ways to automate the lifecycle of applications and services across environments.
- Patterns for deploying virtual applications from infrastructure-as-a-service to platform-as-a-service are described.
Stay productive while slicing up the monolithMarkus Eisele
The document discusses strategies for evolving monolithic applications into microservice architectures. It notes that modern software needs to meet increasing demands around release frequency, developer velocity, and infrastructure costs. While classical architectures based on monoliths and service-oriented architectures were effective, they no longer address today's challenges. The document then introduces microservices as an alternative, describing characteristics like independent deployability, language/data agnosticism, and process isolation. It acknowledges that while building individual microservices is straightforward, the difficult part is designing the overall system architecture and operational capabilities required to manage many interconnected microservices. Lagom is presented as one framework that can help implement reactive microservices on the JVM.
Presentation on the current state of cloud computing and the role that open source, containers and microservices are playing in the cloud.
Presented to Florida Linux Users Exchange on April 9th, 2015
Modernizing Applications with Microservices and DC/OS (Lightbend/Mesosphere c...Lightbend
**Featuring Aaron Williams, Head of Advocacy at Mesosphere, Inc. and Markus Eisele, Developer Advocate at Lightbend, Inc.**
The traditional architecture that enterprises run their businesses on has typically been delivered as monolithic applications running in a virtualized, on-premise infrastructure. Public and private cloud technologies have changed everything, but if the applications are not designed, or re-designed, appropriately, then it is impossible to take advantage of the advances in both distributed application services and hybrid infrastructure. Consequently, enterprise architects are looking to microservices-based architectures as a means to modernize their legacy applications.
This webinar with Lightbend and partner Mesosphere will introduce a new framework specifically designed to help developers modernize legacy Java EE applications into systems of microservices and then discuss exactly what is required to run these distributed systems at enterprise scale.
This document provides an introduction and overview of containers, Kubernetes, IBM Container Service, and IBM Cloud Private. It discusses how microservices architectures break monolithic applications into smaller, independently developed services. Containers are presented as a standard way to package applications to move between environments. Kubernetes is introduced as an open-source system for automating deployment and management of containerized applications. IBM Cloud Container Service and IBM Cloud Private are then overviewed as platforms that combine Docker and Kubernetes to enable deployment of containerized applications on IBM Cloud infrastructure.
Docker concepts and microservices architecture are discussed. Key points include:
- Microservices architecture involves breaking applications into small, independent services that communicate over well-defined APIs. Each service runs in its own process and communicates through lightweight mechanisms like REST/HTTP.
- Docker allows packaging and running applications securely isolated in lightweight containers from their dependencies and libraries. Docker images are used to launch containers which appear as isolated Linux systems running on the host.
- Common Docker commands demonstrated include pulling public images, running interactive containers, building custom images with Dockerfiles, and publishing images to Docker Hub registry.
This document discusses cloud native architectures and microservices. It introduces the speaker and covers topics like how fast software delivery requires decoupling services, using containers and Kubernetes for deployment, and using Apache Camel for integration between microservices. It also discusses using OpenShift and Fuse Integration Services on OpenShift to develop and deploy microservices in a cloud native way.
Exploring microservices in a Microsoft landscapeAlex Thissen
Presentation for Dutch Microsoft TechDays 2015 with Marcel de Vries:
During this session we will take a look at how to realize a Microservices architecture (MSA) using the latest Microsoft technologies available. We will discuss some fundamental theories behind MSA and show you how this can actually be realized with Microsoft technologies such as Azure Service Fabric. This session is a real must-see for any developer that wants to stay ahead of the curve in modern architectures.
Microservices are not for everyone! If you're a small shop, a monolith provides a great amount of value and reduces the complexities involved. However as your company grows, this monolith becomes more difficult to maintain. We’ll look at how microservices allow you to easily deploy and debug atomic pieces of infrastructure which allows for increased velocity in reliable, tested, and consistent deploys. We’ll look into key metrics you can use to identify the right time to begin the transition from monolith to microservices.
This is the slide deck for the DFW Azure User Group meetup of 18 July 2017, presented by Doug Vanderweide and discussing Azure's services that support a microservices architecture.
node.js and Containers: Dispatches from the Frontierbcantrill
This document discusses node.js and containers for microservices architectures. It describes how microservices architectures break large monolithic applications into many smaller independent services. Node.js is well-suited for microservices due to its lightweight footprint and asynchronous nature. Containers provide an efficient way to run many independent services on a single machine by virtualizing at the operating system level. The document outlines lessons learned from rewriting a cloud orchestration system called SmartDataCenter using a microservices and container-based architecture.
The document discusses microservices and how Azure supports the microservices architecture for modern applications. It defines microservices and service-oriented architecture as an approach to building applications as independent, interoperable services. It then describes the various Azure PaaS options for hosting microservices, such as App Service, Functions, and Service Fabric. It also covers supporting Azure services for state management, caching, storage, and monitoring microservices applications. Finally, it provides an example topology of a photo sharing solution built with multiple Azure microservices.
Microservices and serverless for MegaStartups - DLD TLV 2017Boaz Ziniman
Boaz Ziniman, a technical evangelist at AWS, presented on microservices and serverless architectures for mega startups. He discussed how monolithic architectures can limit agility and discussed how microservices help address these issues by decomposing applications into independently deployable services. He then explained how serverless computing removes the need to manage servers by allowing developers to run code without provisioning or managing servers. Examples of serverless offerings from AWS like AWS Lambda were provided. Common use cases for microservices and serverless architectures like web applications, backends, and data processing were also outlined.
The document discusses microservices and provides information on:
- The benefits of microservices including faster time to market, lower deployment costs, and more revenue opportunities.
- What defines a microservice such as being independently deployable and scalable.
- Differences between monolithic and microservice architectures.
- Moving applications to the cloud and refactoring monolithic applications into microservices.
- Tools for building microservices including Azure Service Fabric and serverless/Functions.
- Best practices for developing, deploying, and managing microservices.
Similar to Accelerate DevOps/Microservices and Kubernetes (20)
Just a JSON parser plus a small subset of JSONPath.
Small (currently 4200 lines of code)
Very fast, uses an index overlay from the ground up.
Does not do JavaBean serialization but can serialize into basic Java types and can map to Java classes and Java records.
This talk was done in Feb 2020. Sergey and I co-presented at CTO Forum on Microservices and Service Mesh (how they relate, requirements, goals, best practices and how DevOps and Agile has had convergence in the set of features for Service Mesh and gateways around observability, feature flags, etc.)
Early Draft: Service Mesh allows developers to focus on business logic while the crosscutting network data layer code is handled by the Service Mesh. This is a boon because this code can be tricky to implement and hard to test all of the edge cases. Service Mesh takes this a few steps further than AOP or Servlet Filters or custom language-specific frameworks because it works regardless of the underlying programming language being used which is great for polyglot development shops. Thus standardizing how these layers work, while allowing teams to pick the best tools or languages for the job at hand. Kubernetes and Istio Service Mesh automate best practices for DevSecOps needs like: failover, scale-out, scalability, health checks, circuit breakers, rate limiters, metrics, observability, avoiding cascading failure, disaster recovery, and traffic routing; supporting CI/CD and microservices architecture.
Istio’s ability to automate and maintaining zero trust networks is its most important feature. In the age of high-profile data breaches, security is paramount. Companies want to avoid major brand issues that impact the bottom line and shrink market capitalization in an instant. Istio allows a standard way to do mTLS and auto certificate rotation which helps prevent a breach and limits the blast radius if a breach occurs. Istio also takes the concern of mTLS from microservices deployments and makes it easy to use taking the burden off of application developers.
This document summarizes key points from the book Accelerate about achieving high performance through DevOps practices. It discusses that high performing teams deploy code more frequently with shorter lead times and change fail rates. They use trunk-based development and loosely coupled architectures. Implementing continuous delivery, monitoring, and a lean approach improves software delivery, quality, and reduces burnout. Culture capabilities like learning and collaboration also impact performance. Overall, DevOps practices can double organizational metrics like profitability and productivity. The document advocates transforming through understanding these practices.
Covers how we built a set of high-speed reactive microservices and maximized cloud/hardware costs while meeting objectives in resilience and scalability. Talks about Akka, Kafka, QBit, in-memory computing, from a practitioners point of view. Based on the talks delivered by Geoff Chandler, Jason Daniel, and Rick Hightower at JavaOne 2016 and SF Fintech at Scale 2017, but updated.
Reactive Java: Promises and Streams with Reakt (JavaOne Talk 2016)Rick Hightower
see labs at https://github.com/advantageous/j1-talks-2016
Import based on PPT so there is more notes. This is from our JavaOne Talk 2016 on Reakt, reactive Java programming with promises, circuit breakers, and streams. Reakt is a reactive Java lib that provides promises, streams, and a reactor to handle asynchronous call coordination. It was influenced by the design of promises in ES6. You want to async-call serviceA and then serviceB, take the results of serviceA and serviceB, and then call serviceC. Then, based on the results of call C, call D or E and then return the results to the original caller. Calls to A, B, C, D, and E are all async calls, and none should take longer than 10 seconds. If they do, then return a timeout to the original caller. The whole async call sequence should time out in 20 seconds if it does not complete and should also check for circuit breakers and provide back pressure feedback so the system does not have cascading failures. Learn more in this session.
Reactive Java: Promises and Streams with Reakt (JavaOne talk 2016)Rick Hightower
see labs at https://github.com/advantageous/j1-talks-2016
Import based on PDF. This is from our JavaOne Talk 2016 on Reakt, reactive Java programming with promises, circuit breakers, and streams. Reakt is a reactive Java lib that provides promises, streams, and a reactor to handle asynchronous call coordination. It was influenced by the design of promises in ES6. You want to async-call serviceA and then serviceB, take the results of serviceA and serviceB, and then call serviceC. Then, based on the results of call C, call D or E and then return the results to the original caller. Calls to A, B, C, D, and E are all async calls, and none should take longer than 10 seconds. If they do, then return a timeout to the original caller. The whole async call sequence should time out in 20 seconds if it does not complete and should also check for circuit breakers and provide back pressure feedback so the system does not have cascading failures. Learn more in this session.
High-Speed Reactive Microservices - trials and tribulationsRick Hightower
Covers how we built a set of high-speed reactive microservices and maximized cloud/hardware costs while meeting objectives in resilience and scalability. This has more notes attached as it is based on the ppt not the PDF.
High-speed reactive microservices (HSRM) are microservices that are in-memory, non-blocking, own their data through leasing, and use streams and batching. They provide advantages like lower costs, ability to handle more traffic with fewer resources, and cohesive codebases. The example service described handles 30k recommendations/second on a single thread through batching, streaming, and data faulting. The document discusses attributes of HSRM like single writer rules and service stores, and related concepts like reactive programming, streams, and service sharding.
Netty Notes Part 3 - Channel Pipeline and EventLoopsRick Hightower
Learning more about Netty helps me understand Vert.x better. Netty in Action is a great book. The threading model of Netty is very important to understanding event loops and reactive programming.
Netty Notes Part 2 - Transports and BuffersRick Hightower
This document provides notes on Netty Part 2 focusing on transports and buffers. It discusses the different Netty transport options including NIO, epoll, and OIO. It explains that Netty provides a common interface for different implementations. The document also covers Netty buffers including ByteBuf, direct vs array-backed buffers, composite buffers, and buffer pooling. It emphasizes that performance gains come from reducing byte copies and buffer allocation.
WebSocket MicroService vs. REST MicroserviceRick Hightower
Comparing the speed of RPC calls over WebScoket Microservices versus REST based microservices. Using wrk, QBit, and examples in Java we show how much faster WebSocket is for doing RPC service calls.
Consul: Microservice Enabling Microservices and Reactive ProgrammingRick Hightower
Consul is a service discovery system that provides a microservice style interface to services, service topology and service health.
With service discovery you can look up services which are organized in the topology of your datacenters. Consul uses client agents and RAFT to provide a consistent view of services. Consul provides a consistent view of configuration as well also using RAFT. Consul provides a microservice interface to a replicated view of your service topology and its configuration. Consul can monitor and change services topology based on health of individual nodes.
Consul provides scalable distributed health checks. Consul only does minimal datacenter to datacenter communication so each datacenter has its own Consul cluster. Consul provides a domain model for managing topology of datacenters, server nodes, and services running on server nodes along with their configuration and current health status.
Consul is like combining the features of a DNS server plus Consistent Key/Value Store like etcd plus features of ZooKeeper for service discovery, and health monitoring like Nagios but all rolled up into a consistent system. Essentially, Consul is all the bits you need to have a coherent domain service model available to provide service discovery, health and replicated config, service topology and health status. Consul also provides a nice REST interface and Web UI to see your service topology and distributed service config.
Consul organizes your services in a Catalog called the Service Catalog and then provides a DNS and REST/HTTP/JSON interface to it.
To use Consul you start up an agent process. The Consul agent process is a long running daemon on every member of Consul cluster. The agent process can be run in server mode or client mode. Consul agent clients would run on every physical server or OS virtual machine (if that makes more sense). Client runs on server hosting services. The clients use gossip and RPC calls to stay in sync with Consul.
A client, consul agent running in client mode, forwards request to a server, consul agent running in server mode. Clients are mostly stateless. The client does LAN gossip to the server nodes to communicate changes.
A server, consul agent running in server mode, is like a client agent but with more tasks. The consul servers use the RAFT quorum mechanism to see who is the leader. The consul servers maintain cluster state like the Service Catalog. The leader manages a consistent view of config key/value pairs, and service health and topology. Consul servers also handle WAN gossip to other datacenters. Consul server nodes forwards queries to leader, and forward queries to other datacenters.
A Datacenter is fairly obvious. It is anything that allows for fast communication between nodes, with as few or no hops, little or no routing, and in short: high speed communication. This could be an Amazon EC2 availability zone, a networking environment like a subnet, or any private, low latency, high
The Java microservice lib. QBit is a reactive programming lib for building microservices - JSON, HTTP, WebSocket, and REST. QBit uses reactive programming to build elastic REST, and WebSockets based cloud friendly, web services. SOA evolved for mobile and cloud. QBit is a Java first programming model. It uses common Java idioms to do reactive programming.
It focuses on Java 8. It is one of the few of a crowded field of reactive programming libs/frameworks that focuses on Java 8. It is not a lib written in XYZ that has a few Java examples to mark a check off list. It is written in Java and focuses on Java reactive programming using active objects architecture which is a focus on OOP reactive programming with lambdas and is not a pure functional play. It is a Java 8 play on reactive programming.
Services can be stateful, which fits the micro service architecture well. Services will typically own or lease the data instead of using a cache.
CPU Sharded services, each service does a portion of the workload in its own thread to maximize core utilization.
The idea here is you have a large mass of data that you need to do calculations on. You can keep the data in memory (fault it in or just keep in the largest part of the histogram in memory not the long tail). You shard on an argument to the service methods. (This was how I wrote some personalization engine in the recent past).
Worker Pool service, these are for IO where you have to talk to an IO service that is not async (database usually or legacy integration) or even if you just have to do a lot of IO. These services are semi-stateless. They may manage conversational state of many requests but it is transient.
ServiceQueue wraps a Java object and forces methods calls, responses and events to go through high-speed, batching queues.
ServiceBundle uses a collection of ServiceQueues.
ServiceServer uses a ServiceBundle and exposes it to REST/JSON and WebSocket/JSON.
Events are integrated into the system. You can register for an event using an annotation @EventChannel, or you can implement the event channel interface. Event Bus can be replicated. Event busses can be clustered (optional library). There is not one event bus. You can create as many as you like. Currently the event bus works over WebSocket/JSON. You could receive events from non-Java applications.
Find out more at: https://github.com/advantageous/qbit
Groovy JSON support and the Boon JSON parser are up to 3x to 5x faster than Jackson at parsing JSON from String and char[], and 2x to 4x faster at parsing byte[].
Groovy JSON support and Boon JSON support are also faster than Jackson at encoding JSON strings. Boon is faster than Jackson at serializing/de-serializing Java instances to/fro JSON. The core of the Boon JSON parser has been forked into Groovy 2.3 (now in Beta). In the process Boon JSON support was improved and further enhanced. Groovy and Boon JSON parsers speeds are equivalent. Groovy now has the fastest JSON parser on the JVM.
MongoDB quickstart for Java, PHP, and Python developersRick Hightower
Quick introduction to MongoDB.
Covers major features, CRUD, DB operations, comparison to SQL, basic console, etc.
Covers architecture of Replica Sets, Autosharding, MapReudce, etc.
Examples in JavaScript, Java, PHP and Python.
BT & Neo4j: Knowledge Graphs for Critical Enterprise Systems.pptx.pdfNeo4j
Presented at Gartner Data & Analytics, London Maty 2024. BT Group has used the Neo4j Graph Database to enable impressive digital transformation programs over the last 6 years. By re-imagining their operational support systems to adopt self-serve and data lead principles they have substantially reduced the number of applications and complexity of their operations. The result has been a substantial reduction in risk and costs while improving time to value, innovation, and process automation. Join this session to hear their story, the lessons they learned along the way and how their future innovation plans include the exploration of uses of EKG + Generative AI.
UiPath Community Day Kraków: Devs4Devs ConferenceUiPathCommunity
We are honored to launch and host this event for our UiPath Polish Community, with the help of our partners - Proservartner!
We certainly hope we have managed to spike your interest in the subjects to be presented and the incredible networking opportunities at hand, too!
Check out our proposed agenda below 👇👇
08:30 ☕ Welcome coffee (30')
09:00 Opening note/ Intro to UiPath Community (10')
Cristina Vidu, Global Manager, Marketing Community @UiPath
Dawid Kot, Digital Transformation Lead @Proservartner
09:10 Cloud migration - Proservartner & DOVISTA case study (30')
Marcin Drozdowski, Automation CoE Manager @DOVISTA
Pawel Kamiński, RPA developer @DOVISTA
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
09:40 From bottlenecks to breakthroughs: Citizen Development in action (25')
Pawel Poplawski, Director, Improvement and Automation @McCormick & Company
Michał Cieślak, Senior Manager, Automation Programs @McCormick & Company
10:05 Next-level bots: API integration in UiPath Studio (30')
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
10:35 ☕ Coffee Break (15')
10:50 Document Understanding with my RPA Companion (45')
Ewa Gruszka, Enterprise Sales Specialist, AI & ML @UiPath
11:35 Power up your Robots: GenAI and GPT in REFramework (45')
Krzysztof Karaszewski, Global RPA Product Manager
12:20 🍕 Lunch Break (1hr)
13:20 From Concept to Quality: UiPath Test Suite for AI-powered Knowledge Bots (30')
Kamil Miśko, UiPath MVP, Senior RPA Developer @Zurich Insurance
13:50 Communications Mining - focus on AI capabilities (30')
Thomasz Wierzbicki, Business Analyst @Office Samurai
14:20 Polish MVP panel: Insights on MVP award achievements and career profiling
Measuring the Impact of Network Latency at TwitterScyllaDB
Widya Salim and Victor Ma will outline the causal impact analysis, framework, and key learnings used to quantify the impact of reducing Twitter's network latency.
論文紹介:A Systematic Survey of Prompt Engineering on Vision-Language Foundation ...Toru Tamaki
Jindong Gu, Zhen Han, Shuo Chen, Ahmad Beirami, Bailan He, Gengyuan Zhang, Ruotong Liao, Yao Qin, Volker Tresp, Philip Torr "A Systematic Survey of Prompt Engineering on Vision-Language Foundation Models" arXiv2023
https://arxiv.org/abs/2307.12980
TrustArc Webinar - 2024 Data Privacy Trends: A Mid-Year Check-InTrustArc
Six months into 2024, and it is clear the privacy ecosystem takes no days off!! Regulators continue to implement and enforce new regulations, businesses strive to meet requirements, and technology advances like AI have privacy professionals scratching their heads about managing risk.
What can we learn about the first six months of data privacy trends and events in 2024? How should this inform your privacy program management for the rest of the year?
Join TrustArc, Goodwin, and Snyk privacy experts as they discuss the changes we’ve seen in the first half of 2024 and gain insight into the concrete, actionable steps you can take to up-level your privacy program in the second half of the year.
This webinar will review:
- Key changes to privacy regulations in 2024
- Key themes in privacy and data governance in 2024
- How to maximize your privacy program in the second half of 2024
Fluttercon 2024: Showing that you care about security - OpenSSF Scorecards fo...Chris Swan
Have you noticed the OpenSSF Scorecard badges on the official Dart and Flutter repos? It's Google's way of showing that they care about security. Practices such as pinning dependencies, branch protection, required reviews, continuous integration tests etc. are measured to provide a score and accompanying badge.
You can do the same for your projects, and this presentation will show you how, with an emphasis on the unique challenges that come up when working with Dart and Flutter.
The session will provide a walkthrough of the steps involved in securing a first repository, and then what it takes to repeat that process across an organization with multiple repos. It will also look at the ongoing maintenance involved once scorecards have been implemented, and how aspects of that maintenance can be better automated to minimize toil.
The Rise of Supernetwork Data Intensive ComputingLarry Smarr
Invited Remote Lecture to SC21
The International Conference for High Performance Computing, Networking, Storage, and Analysis
St. Louis, Missouri
November 18, 2021
7 Most Powerful Solar Storms in the History of Earth.pdfEnterprise Wired
Solar Storms (Geo Magnetic Storms) are the motion of accelerated charged particles in the solar environment with high velocities due to the coronal mass ejection (CME).
YOUR RELIABLE WEB DESIGN & DEVELOPMENT TEAM — FOR LASTING SUCCESS
WPRiders is a web development company specialized in WordPress and WooCommerce websites and plugins for customers around the world. The company is headquartered in Bucharest, Romania, but our team members are located all over the world. Our customers are primarily from the US and Western Europe, but we have clients from Australia, Canada and other areas as well.
Some facts about WPRiders and why we are one of the best firms around:
More than 700 five-star reviews! You can check them here.
1500 WordPress projects delivered.
We respond 80% faster than other firms! Data provided by Freshdesk.
We’ve been in business since 2015.
We are located in 7 countries and have 22 team members.
With so many projects delivered, our team knows what works and what doesn’t when it comes to WordPress and WooCommerce.
Our team members are:
- highly experienced developers (employees & contractors with 5 -10+ years of experience),
- great designers with an eye for UX/UI with 10+ years of experience
- project managers with development background who speak both tech and non-tech
- QA specialists
- Conversion Rate Optimisation - CRO experts
They are all working together to provide you with the best possible service. We are passionate about WordPress, and we love creating custom solutions that help our clients achieve their goals.
At WPRiders, we are committed to building long-term relationships with our clients. We believe in accountability, in doing the right thing, as well as in transparency and open communication. You can read more about WPRiders on the About us page.
Scaling Connections in PostgreSQL Postgres Bangalore(PGBLR) Meetup-2 - MydbopsMydbops
This presentation, delivered at the Postgres Bangalore (PGBLR) Meetup-2 on June 29th, 2024, dives deep into connection pooling for PostgreSQL databases. Aakash M, a PostgreSQL Tech Lead at Mydbops, explores the challenges of managing numerous connections and explains how connection pooling optimizes performance and resource utilization.
Key Takeaways:
* Understand why connection pooling is essential for high-traffic applications
* Explore various connection poolers available for PostgreSQL, including pgbouncer
* Learn the configuration options and functionalities of pgbouncer
* Discover best practices for monitoring and troubleshooting connection pooling setups
* Gain insights into real-world use cases and considerations for production environments
This presentation is ideal for:
* Database administrators (DBAs)
* Developers working with PostgreSQL
* DevOps engineers
* Anyone interested in optimizing PostgreSQL performance
Contact info@mydbops.com for PostgreSQL Managed, Consulting and Remote DBA Services
Coordinate Systems in FME 101 - Webinar SlidesSafe Software
If you’ve ever had to analyze a map or GPS data, chances are you’ve encountered and even worked with coordinate systems. As historical data continually updates through GPS, understanding coordinate systems is increasingly crucial. However, not everyone knows why they exist or how to effectively use them for data-driven insights.
During this webinar, you’ll learn exactly what coordinate systems are and how you can use FME to maintain and transform your data’s coordinate systems in an easy-to-digest way, accurately representing the geographical space that it exists within. During this webinar, you will have the chance to:
- Enhance Your Understanding: Gain a clear overview of what coordinate systems are and their value
- Learn Practical Applications: Why we need datams and projections, plus units between coordinate systems
- Maximize with FME: Understand how FME handles coordinate systems, including a brief summary of the 3 main reprojectors
- Custom Coordinate Systems: Learn how to work with FME and coordinate systems beyond what is natively supported
- Look Ahead: Gain insights into where FME is headed with coordinate systems in the future
Don’t miss the opportunity to improve the value you receive from your coordinate system data, ultimately allowing you to streamline your data analysis and maximize your time. See you there!
An invited talk given by Mark Billinghurst on Research Directions for Cross Reality Interfaces. This was given on July 2nd 2024 as part of the 2024 Summer School on Cross Reality in Hagenberg, Austria (July 1st - 7th)
Support en anglais diffusé lors de l'événement 100% IA organisé dans les locaux parisiens d'Iguane Solutions, le mardi 2 juillet 2024 :
- Présentation de notre plateforme IA plug and play : ses fonctionnalités avancées, telles que son interface utilisateur intuitive, son copilot puissant et des outils de monitoring performants.
- REX client : Cyril Janssens, CTO d’ easybourse, partage son expérience d’utilisation de notre plateforme IA plug & play.
Understanding Insider Security Threats: Types, Examples, Effects, and Mitigat...Bert Blevins
Today’s digitally connected world presents a wide range of security challenges for enterprises. Insider security threats are particularly noteworthy because they have the potential to cause significant harm. Unlike external threats, insider risks originate from within the company, making them more subtle and challenging to identify. This blog aims to provide a comprehensive understanding of insider security threats, including their types, examples, effects, and mitigation techniques.
Kief Morris rethinks the infrastructure code delivery lifecycle, advocating for a shift towards composable infrastructure systems. We should shift to designing around deployable components rather than code modules, use more useful levels of abstraction, and drive design and deployment from applications rather than bottom-up, monolithic architecture and delivery.
5. ABOUT RICK• Author of best-selling agile development book, early adopter of TDD, DevOps,
Agile, etc.
• Highest leadership scores of any senior director in a 2,000 person org (happiest,
most productive team). Highest performing team in a 1,000+ person group: Jenkins
pipelines, Event Hub/EEL, High-code coverage, PR process, Trunk based git like
GitHub flow, full automation, etc.
• Two awards from CIO at fortune 500, amazing results (G.O.A.T and Engineering
Excellence)
• Amazing results finishing projects deemed impossible under tight deadlines. Grew
team from 12 to 50+, Talent Magnet due to culture of excellence
• Written open source software used by millions
• Early adopter and proponent of MicroServices and streaming high-speed streaming,
12 factor deployment, container orchestration, in-memory compute and uService
architecture
• Speaker at conferences on microservice development, a Java Champion (chosen
from 10,000,000 Java Developers), parsers, distributed data grids, books, articles,
etc.
• Mentoring, consulting, papers, blogs, specifications, JSRs for distributed compute,
streaming
6. SLIDE DECK BASED ON
BOOK ACCELERATE AND
MORE• PAST
EXPERIENCE
• LATEST
TRENDS
7. OUTLINE
• How we got here
• History of MicroServices
• DevOps / Agile
• CI/CD
• Kubernetes
• Best practices
• Continuous delivery
• Continuous integration
• Lean management and
monitoring / KPIs
• SCM / Version Control
/ GitOps / Immutable
infrastructure
• Trunk-based
development
8. BRIEF HISTORY OF MICROSERVICES
AND AGILE,CI/CD
Brief history of time
9. HOW WE GOT HERE
• Web pages that were brochures
• eCommerce
• Legacy integration
• Rush to Webify businesses
• SOA: Wrap legacy systems as services to use from web
• Virtualization, Virtualization2.0, Cloud, Containers, and now
Container orchestration
10. “Now you can run a JVM in a Docker image which is
just a process pretending to be an OS running in an
OS that is running in the cloud which is running inside
of a virtual machine which is running in Linux server
that you don’t own that you share with people who you
don’t know.”
Microservices Architecture
11. “The Java EE container is no longer needed because
servers are not giant refrigerator boxes that you order
from Sun and wait three months for (circa 2000). Don’t fight
classpath, classloader hell of Java EE. … your whole … OS is
now an ephemeral container (Docker). Deliver an image with all
the libs you need, don’t deploy to a Java EE server which has
to be versioned and configured. You are only running one
service in it anyway.… Let it go. …One issue with enterprise
components is they assume the use of hardware servers
which are large monoliths and you want to run a lot of
things on the same server. Well, turns out in (today), that
makes no sense. Operating systems and servers are
ephemeral, virtualized resources and can be shipped like a
component. We have EC2 images AMIs, OpenStack, Vagrant,
Kubernetes and Docker. The world changed. Move on….
Microservices just recognize this trend so you are not
developing like you did when the hardware, cloud
orchestration, multi-cores, and virtualization was not there.
You did not develop code in the 90s with punch cards did
you? So don’t use an EAR file or a WAR file (today).”
Microservices Architecture
12. MICROSERVICES
• Focus is building small, reusable, scalable services
• Adopt the Unix single purpose utility approach to service
development
• Small so they can be released more often and are written to be
malleable
• Easier to write
• Easier to change
• Go hand in hand with continuous integration and continuous
delivery
• Heavily REST based and messagingWhat is microservice architecture?Microservices Architecture
13. KEY INGREDIENT OF
MICROSERVICES
• independently deployable, small, domain-driven services
• Own their data (no shared databases)
• communication through a well-defined wire protocol
usually JSON over HTTP (curl-able interfaces)
• well defined interfaces and minimal functionality
• avoiding cascading failures and synchronous calls -
reactive designing for failure
What is microservice architecture?
14. SOA VS. MICROSERVICES
• SOA and Microservices have common goals and
purposes
• Refinement to meet goals of polyglot devices and
3rd generation virtualization (cloud, container,
container orchestration)
• Parts of SOA that worked well
• MS: Web technologies to provide scalability,
modular, domain-drive, small, and continuously
deployable cloud-based services
What is microservice architecture?
It’s not the daily
increase but daily
decrease. Hack away
at the unessential. --
Bruce Lee
15. SOA VS. MICROSERVICES
“Microservices Architecture is taking what perhaps started out as SOA and
applying lessons learned as well as pressure to support polyglot devices,
deploy more rapidly and the architecture liquidity that cloud computing and
virtualization/containerization provide. You mix all that together and you
can see where Microservices Architecture started. Microservices
Architecture is in general less vendor driven than SOA and more needs
driven by demands of application development and current cloud
infrastructure.” —Rick Hightower 2013 :)
16. UNIX PHILOSOPHY
• Microservices compares to Unix philosophy,
• Ken Thompson, Unix creator, said Unix has a
philosophy of:
one tool, one job
• “Unix philosophy emphasizes building short, simple,
clear, modular, and extendable code that can be
easily maintained and repurposed by developers
other than its creators” What is microservice architecture?
17. COPING WITH FAILURE
• Avoid synchronous calls to avoid cascading
failures
• Microservices tend to embrace streams,
queues, actor systems, event loops and
other async calls
• Spend more time with distributed logging /
log aggregation w/ MDC and now distributed
tracing
18. MICROSERVICES
MONITORING
• User Experience KPIs
• Debugging (requests per second,
#threads, #connections, failed auth,
expired tokens, etc.)
• Circuit Breaker (monitor health, restarts,
act/react)
• Cloud Orchestration (monitor load, spin
up instances)
• Health checks and observable KPIs
"doveryai no proveryai"
(trust, but verify)
Microservice Monitoring
19. “Just remember Microservices are not a new
thing, and they are not cool or hip.
Microservices are obvious evolutionary
architecture to address the revolutionary things
that already happened: web, cloud, mobile,
server virtualization, OS containerization,
container orchestration, multi-core servers,
cheaper and cheaper RAM, 64 bit computing,
10GBE, 100GBE, etc.”
Microservices Architecture
20. MICROSERVICES ARE
CONTINUOUSLY DEPLOYABLE
SERVICES
• Microservices focus on business capability,
and a refocus on object oriented
programming roots and organizing code
around business domains with data and
business rules co-located in the same
process or set of processes
21. CONTINUOUSLY
DEPLOYABLE
MICROSERVICES• Focus of Microservices is on breaking up applications into
small (micro) reusable services which might be useful to
other services or other applications.
• Services can be deployed independently
• Each of these services to be tweaked, and then
redeployed independently
• This is where the "micro" part of microservices comes
into play
What is microservice architecture?
23. XP, AGILE, SCRUM, TDD,
CI/CD
• TDD, CI and CI/CD
• Test Driven Development and Agile
• XP, Agile, Scrum
• CI/CD (Jenkins and the tools that came
before)
• CI/CD needs automated testing
24. DEVOPS
• DevOps aka DevSecOps
• Heroku and the birth of 12 factor deployment, DevOps, KPIs, SRE
• YBYOI vs. SRE vs. DevOps and where do you fit?
• SRE: Observability, Log aggregation, KPIs/Metrics, Distributed/Trace
logging
• Container Orchestration: Yarn, Mesos, Marathon, Nomad, Borg and
Kubernetes
• What is GitOps? What is immutable infrastructure?
• What is cloud native?
25. KUBERNETES / K8S
• Services, Stateful sets, Namespaces, Tags, Ingress, Egress
• Helm/Kustomize for packaging an app or set of related uServices and deploy to
K8s
• Multi-cloud support and just cloud support
• Monitoring built-in (or at least easily pluggable)
• Easy to ramp up (or easier)
• Supports flexible deployment models
• Integrates with Cloud providers services or runs standalone (on prem or cloud)
• What came before and now: Heroku/PaaS/IAAS/EC2, Docker, Docker Swarm,
Mesos/Marathon, Nomad, ECS, EKS, etc. K8s is the current mindshare champ.
28. ACCELERATION IN
PRACTICE
• Make more money
• Deliver more
• Less Burnout
• Grow the value of the
company
• Make customers happy
29. ORGANIZATIONAL
PERFORMANCE
• High performers 2x the rate will exceed organizational
performance goals as low performers:
• 2x profitability
• 2x productivity
• 2x market share
• 2x number of customers
30. ORGANIZATIONAL
PERFORMANCE PART II
• High performers twice as likely to exceed non-commercial
performance goals as low performers
• 2x better quantity of products and services
• 2x operating efficiency
• 2x customer satisfaction
• 2x quality of products/services
• 2x achieving organizational/mission goals
32. SOFTWARE DELIVERY
PERFORMANCE
• Deploy frequency, Lead time, mean time to restore (MTTR),
and change fail percentage do well to predict overall software
delivery performance
• Improving software delivery performance improves tempo and
stability
• Software delivery performance improves organizational
performance and quality/customer satisfaction
• Deploy frequency is highly correlated with continuous delivery
and use of version control best practices
33. SOFTWARE DELIVERY
PERFORMANCE II
• Lead time is highly correlated with good version control
and automated testing
• MTTR is highly correlated with version control and
monitoring
• Software delivery performance is negatively correlated
with deployment pain
• Software delivery performance is correlated with
organizational investment in DevOps
34. QUALITY
Source, Forsgren PhD, Nicole. Jez Humble, Gene Kim, Accelerate . IT Revolution Press. Kindle Edition.
st amount of manual work across all practices - configuration m
35. CULTURE
• 5 factors most associated with burnout are
negatively impacted by bad software delivery
performance
• Deployment pain and poor software delivery
practices cause organizational burnout
36. IMPROVE CULTURE BY
IMPROVING PRACTICES• Technical practices predict continuous delivery
• Improve organizational culture, identity, job
satisfaction, software delivery performance, less
burnout, less deployment pain, and less time
spent on rework!
• High performers spend 50% less time
remediating security issues than low
performers
37. TRUNK BASED DEVELOPMENT
(LIKE GITHUB FLOW)
• High performers have shortest integration times
and branch lifetimes
• Branch life and integration typically lasting hours
or a day
• Low performers have longest integration times
and branch lifetimes
• Branch life and integration typically lasting days or
weeks
38. ARCHITECTURE
• Loosely coupled, well-encapsulated
architecture drives IT performance.
• 2017 dataset biggest contributor to
continuous delivery was loosely coupled,
well-encapsulated architecture
39. LEAN PRODUCT
MANAGEMENT
CAPABILITIES• Experimental approach to product
development highly correlates with
continuous delivery
• Lean product development capabilities
predict improvements in organizational
culture like reduced burnout higher software
delivery performance and overall
organizational performance
41. ACCELERATE DEVOPS
• Continuous delivery
• Architecture
• Product and process
• Lean Management and monitoring
• Cultural
42. CONTINUOUS DELIVERY
CAPABILITIES
1. Implement continuous delivery / continuous deployment
2. Version control all production artifacts
3. Automate your deployment pipeline
4. Implement continuous integration
5. Use trunk-based development methods (like Github flow
instead of git flow)
6. Implement test automation
7. Shift left on security
43. PRODUCT AND PROCESS
CAPABILITIES
• Gather and implement customer feedback
• Make the flow of work through the system
visible
• Work in small batches
• Foster and enable team experimentation
44. CULTURE CAPABILITIES
• Support a generative culture
• Encourage and support learning
• Encourage collaboration
• Make work as meaningful as possible
• Support and encourage transformational
leadership
46. ARCHITECTURAL
CAPABILITIES TO
ACCELERATE
• Use loosely coupled architecture
• Release new services on demand
without outages
• Empower the team to select tools; trust team
to pick the best tools
47. LEAN MANAGEMENT AND
MONITORING
CAPABILITIES• Have a light weight change approval process
• Monitor application and system KPIs to inform business
decisions
• Proactively check system health
• Preemptively detect and mitigate problems
• Improve process and work within WIP limits
• Set up visible dashboards to monitor/communicate WIP,
quality, applications and systems
49. LEAN MANAGEMENT
• Process: Small Batches
• Decompose into features that allow for rapid development
• MVP - prototype with just enough features to proved business value or enable validated
learning
• Quickly gather customer requirements (A/B testing, customer satisfaction surveys, etc.)
• Team experimentation
• Lean Management: Change approval
• Lean Management: Proactive notification
• Lean Management: Monitoring and KPIs
• Lean Management: WIP limits, visualizing work
50. Companies with regulatory requirements or strict CCB
Can focus on Continuous Delivery
Continuous Deployment can be part of a workflow and
Based on the Continuous Delivery
51. VERSION CONTROL - SCM
• GitOps - keeping application code, system configuration,
application configuration, and scripts for automating
build and configuration in version control.
• Factors together predict IT performance
• Key component of continuous delivery
• GitOps - keeping system and application config in git
(versioned) correlates high with delivery performance
52. DEPLOYMENT
AUTOMATION
• Deployment automation
• Containers, config, immutable infrastructure
• Comprehensive configuration management
(automation scripts), continuous integration and
continuous testing
• Key metric of GitOps is how much diffs exists in
system config from git to deploy
54. TRUNK-BASED
DEVELOPMENT
• Trunk-based development
• Like GitHub Flow but shorter lived branches
• Fewer active branches that never outlive a sprint
• Branch-off master per feature, bug fix, etc.
• More PRs more often
• No code freezes; integration periods less than a day
• Polar opposite of git flow
55. SHIFT LEFT ON SECURITY
• Integrating security into design and testing
phases
• Security reviews of applications, including
the infosec team in design and demo
process
• Using pre-approved security libraries and
packages, and testing security features as a
part of automated testing suite
56. CONTINUOUS DELIVERY
• The ability to deliver
• Build quality in
• Work in small batches
• Automate repetitive tasks including testing &
deployments
• Pursue continuous improvement
• Ownership
• Comprehensive configuration management
• Continuous integration
• Continuous testing
You can’t skip steps.
There is investment
up front.
Today’s speed up can
be tomorrows painted
yourself
In a corner.
58. PREFER MICROSERVICES
BUT…
• Know when to employ Monolith and when not to
• Can speed up MVP and prototypes but at a cost
• Why this makes CI/CD slower?
• Automated tests needed for CI/CD
• Smaller Monoliths and SOA is a move in the right
direction
59. PREFER MICROSERVICES
• Refactoring to Microservices is a journey
• Know when to employ Microservices
• Fits the CI/CD well
• Fits small batch well
• How Micro can mean different things as you get better at
Microservices
• Why today's micro could be tomorrows Monolith?
• Adoption is a Journey
60. EMBRACE OBSERVABILITY
FROM THE START
• Log aggregation
• Time series data base
• Log all KPIs for clusters
• Log all KPIs for applications and services
• Alerting
• Know when and how to employ distributed tracing
• Distributed/Trace logging
61. CI/CD
• CI/CD
• Deploy often (daily or more)
• Test often (after every checkin run all
automated tests)
• Block PRs from merging until they pass tests
62. TESTS TO CREATE: TDD
• Unit tests
• Perf testing JMH
• Functional tests
• At the HTTP
layer
• At the Spring
Boot layer
• Acceptance tests
• Smoke integration tests
• Full integration tests
• Synthetic testing
• Code Coverage (sonarqube)
• Security/Vulnerability dependency license
checks
• Aqua, Fortify
• Full integration perf testing
63. WHAT IS A PR? AND HOW
TO ENSURE QUALITY WITH
IT• A PR is a pull-request
• PR gives other developers a chance to review code before it
committed to master
• PR via small batch (why small? JIRA story or even a tasks or two)
• With GitHub and WebHooks you can block PRs from merging
• Code coverage met, build works, unit tests run, other checks via
Jenkins
• Review and approved by at least two people
64. TESTING IS A MUST!
• You can't do CI/CD without automated
testing
• Testing allows you to move quickly with
confidence
65. EMBRACE SMALL BATCH
WORK
• Goal of three PRs per week
• Goal of one to two tasks from JIRA per PR
• Use JIRA # in commits and PR comments
66. AUTOMATED
DEPLOYMENT
• Merging into master triggers a deploy to integration and sends a Team message
• Approval from Product Manager pushes code to Prod or Demo
• Checking into main branch from PR
• Artifacts and scripts for deployment checked into git and should not be modified
• Puts code staging area to be checked by Product Manager
• into containers and deploys to cluster (some ephemeral some not)
• Once checked by Infosec and Product Manager: Canary Deploys to 3 to 5% of
traffic and is monitored (end goal)
• Then more and more as it is monitored and is ok
69. TRANSFORMATION IS A
BUSINESS IMPERATIVE• You can’t afford not to transform
• Transformation requires a deep understanding of
practices
• Having a team called DevOps is not doing DevOps
per se
• Culture of DevOps, Agility, Lean, MVP, etc. is a
clear win
• There are guides, books, practices, and information
70. Read Accelerate by Forsgren PhD, Nicole. Jez Humble, Gene Kim.
Also read The Loop Approach: How to Transform your organization from
The inside out! By Sebastian Klein and Ben Hughes
Also read Cloud Native DevOps with Kubernetes by John Arundel and Justin Domingus
Editor's Notes
Rick Hightower
Rick consults and does contract development for high-speed computing, Java-based uServices, Apache Spark, Apache Kafka, and Apache Cassandra. He also writes about microservice development and reactive streaming. Rick is a frequent speaker regarding high-speed, reactive microservice development and has spoken recently at JavaOne as well at FinTech at scale in SF. He specializes in high-speed, in-memory, non-blocking, microservices development which often includes Java EE, QBit, Reakt, Akka, Vert.x, Cassandra, Kafka, and cloud deployments. He has architected and implemented 100 million-users, in-memory content preference engines using Java reactive, streaming, and actor-based system as well as architected and implemented OAuth rate limiter (API gateway) for streaming music service to rate limit all backend services per partner/vendor/mobile app. Rick also contributed to the reference implementations enterprise caches as well as being a member of several spec. committees (JSR-347, JSR-107, etc.). He also is the author of the Boon JSON parser and parsing utilities which ships with Groovy.
Enterprise Applications flashback
While it is true Enterprise Applications are often built with a three tier architecture: backend code, database code and a GUI written in HTML/JavaScript. This has more to do with the world changing than an active choice. The real drivers for Microservices Architecture are cloud/virtualization/OS containerization, EC2, proliferation of mobile devices, cheaper memory, more virtualization, more cores, SSD, trend towards fatter clients, 10 GBE, 100 GBE, etc. The big enterprise web app is becoming obsolete to a certain extent at least for large applications. It is not like we one day came up with a better idea, and then one day we were like hey what if we could make our code more modular. The ground changed under our collective feet. The way we build, deploy, and consume has changed. Hardware evolved. Virtualization evolved. Containerization happened. Cloud computing became a real thing, and so compelling that it is hard to ignore. The smart phone / tablet / mobile revolution happened. Microservice is the response to these external events.
Microservices and NoSQL are two trends that are more focused on how to address software development where deployments are increasingly cloud based and clients are increasingly mobile based. Just like you can’t compare client / server development of the mid-90s to mainframe development from the 70s, you can’t compare enterprise applications from 2001 to microservice development targeting mobile and web clients and other microservices in 2015. The world changes. We adjust. Microservice trend is course correction not a new religion.
History of Enterprise Applications
Remember 1990s, the reason why Enterprise Applications are written with three tiers was was to avoid DLL hell, and the monolith. We just did it with the tools available at the time. Back in the day, we used to build apps that were two tiered. You had to actually go to each users machine and help them install the app. There was a damn good chance they downloaded some shareware that installed a DLL that screwed up the install, and you were in hell. It was not like we were, “Hey James!” .. “What Martin?” “Do you want to build a huge monolith?” “Sure Martin!”.
We tried Applets but Java GUI development back then sucked (1999). I don't think it sucks so bad now, but it lost its window of opportunity for adoption. Then we were left with HTML/JavaScript clients and forcing everyone to use the same browser in the corporation at least for the corporate apps. I worked at many corporations (2003) that banned JavaScript due to incompatibilities of browsers. You were left with screen painting with HTML. It was a like a colorful green screen of yesteryear, but way slower, but pretty. There are many reasons why this style of “Enterprise Development” does not work in the cloud and for mobile devices. The server-side applications no longer need to handle HTTP requests, get data from a database and execute all domain logic, and draw pretty pictures in HTML. Much pain, and great expense has been incurred trying get this three tier architecture to scale in the cloud for various devices written in a polyglot of languages. Microservices exists because mobile, cloud, cheaper RAM, cheaper disks, and improved virtualization. It is really just taking the world where it is. It is not revolutionary at all.
Server components, EAR files and WAR files.. may they rest in peace
If you have lived through COM, DCOM, CORBA, EJBs, OSGi, J2EE, SOAP, SOA, DCE, etc. then you know the idea of services and components is not a new thing, but they are a date expired concept for the most part. One issue with enterprise components is they assume the use of hardware servers which are large monoliths and you want to run a lot of things on the same server. That is why we have WAR files and EAR files, and all sorts of nifty components and archives. Well turns out in 2015 (and less so in 2019), that makes no sense. Operating systems and servers are ephemeral, virtualized resources and can be shipped like a component. We have EC2 images AMIs, OpenStack, Vagrant and Docker. The world changed. Move on. Microservices just recognize this trend so you are not developing like you did when the hardware, cloud orchestration, multi-cores, and virtualization was not there. You did not develop code in the 90s with punch cards did you? So don’t use an EAR file or a WAR file in 2015.
Now you can run a JVM in a Docker image which is just a process pretending to be an OS running in an OS that is running in the cloud which is running inside of a virtual machine which is running in Linux server that you don’t own that you share with people who you don’t know. Got a busy season? Well then, spin up 100 more server instances for a few weeks or hours. This is why you run Java microservices as standalone processes and not running inside of a Java EE container.
The Java EE container is no longer needed because servers are not giant refrigerator boxes that you order from Sun and wait three months for (circa 2000). Don’t fight classpath, classloader hell of Java EE. Hell your whole damn OS is now an ephemeral container (Docker). Deliver an image with all the libs you need, don’t deploy to a Java EE server which has to be versioned and configured. You are only running one service in it anyway. Turns out you don’t have five war files running in the same Java EE container since oh about 2007. Let it go.
If you are deploying a WAR file to a Java EE container then you are probably not doing microservice development. If you have more than one WAR file in the container or an EAR file, then you are definitely not doing microservice development. If you are deploying your service as an AMI or docker container and your microservice has a main method, then you might be writing a microservice.
Microservices architectures opt to break software not into components but into reusable, independently release-able services which run as one or more processes. Application and other services communicate with each other. So where we might have used a server side component, we use a microservice running in independent processes. Where we might have had WAR files or EAR files now we have a Docker container or a Amazon AMI that has the entire app preloaded and configure with exactly the libraries it needs (Java and otherwise).
JSON, HTTP, WebSocket … NO WSDL!
Now you just have to document the Microservices HTTP/JSON interface so other developers can call into it. We could say REST, and certainly you can use concepts from REST, but hey HTTP calls are enough to be considered a Microservice.
Keep this in mind: No XML. No SOAP. No WSDL. No WADL. JSON! Ok you can add some meta data and document how to talk to your service, but the idea is the docs should be documented with curl. If you are only using SOAP or XML then you are not producing a microservice. JSON is a must.
Documents should sound more like: I give you this request with these headers, params and JSON body and you respond with this JSON. Keep it simple. You can provide things in addition to JSON, but JSON is the minimum requirement. If you are not delivering up JSON and consuming JSON over HTTP or HTTP WebSocket then what you wrote is not probably not a microservice.
Introduction To Microservices
Microservice architecture is a method of developing software systems. Its focus is building small, reusable, scalable services. Applying Microservices becomes very important when you have to create services for polyglot devices: wearables, Internet of Things (IOT), mobile, desktop, and web. The trend towards providing services for rich, native mobile application and web applications started the trend towards Microservices adoption. This is one reason why microservices lean heavily on web technologies like HTTP/REST/WebSocket with JSON,Message Pack, and their ilk. The web technologies provide a low barrier to entry and least common denominator to communication.
The closest to a standard definition of microservices is Microservices by James Lewis and Martin Fowler.
…
Continuous delivery: The microservices architectural approach is to create smaller services that are focused on a small business domain or crosscutting concern. Microservices adopt the Unix single purpose utility approach to service development. They are small so they can be released more often and are written to be malleable. They are easier to write. They are easier to change. Microservices go hand in hand with continuous integration and continuous delivery. The services are independent enough not to need a gigantic release train to release improvements or new features. In the Java world, this means you will be using other microservice like Jenkins to provide frequent releases.
Key ingredients to microservices architecture are:
independently deployable, small, domain-driven services
communication through a well-defined wire protocol usually JSON over HTTP (curl-able interfaces)
well defined interfaces and minimal functionality
avoiding cascading failures and synchronous calls - reactive designing for failure
This comes up a lot so let's address this now.
It is very common for some to confuse Service-Oriented Architecture (SOA) and Microservice Architecture. In a sense, SOA and Microservice Architecture are related in some goals and purposes.
Microservices is a refocus and refinement of some of the original goals of SOA to meet the demands of a polyglot device environment that can scale and support continuous deployments in a cloud / third generation virtualization environment.
Since SOA was later muddled with BPEL, ESBs, SOAP, WSDL, and their ilk, it is easier to drop the SOA moniker and just focus on the parts that worked well. Keep the parts that work. Get rid of the rest.
The focus on Microservices Architecture is web technologies to provide scalability, modular, domain-drive, small, and continuously deployable cloud-based services.
Microservices Architecture is taking what perhaps started out as SOA and applying lessons learned as well as pressure to support polyglot devices, deploy more rapidly and the architecture liquidity that cloud computing and virtualization/containerization provide. You mix all that together and you can see where Microservices Architecture started. Microservices Architecture is in general less vendor driven than SOA and more needs driven by demands of application development and current cloud infrastructure.
For more thoughts on SOA vs. Microservices read Microservices Architecture.
Microservices Architecture is taking what perhaps started out as SOA and applying lessons learned as well as pressure to support polyglot devices, deploy more rapidly and the architecture liquidity that cloud computing and virtualization/containerization provide. You mix all that together and you can see where Microservices Architecture started. Microservices Architecture is in general less vendor driven than SOA and more needs driven by demands of application development and current cloud infrastructure.
Cope with failure
Microservices are designed to cope with failure. Since microservices tend to call each other, a downstream service that fails should not block upstream services and clients. Synchronous communication is avoided to avoid cascading failures. Thus Microservices tend to embrace async calls, streams, queues and actor systems. To handle failure, it is easier to embrace Queue theory so you can detect failure and provide alternatives or just fail gracefully without blocking clients. The ability to react to failure is a key characteristic of Microservices.
In order to learn about downstream failure or learn about other functioning nodes and implement some sort of circuit breaker, one needs Service Discovery. Tools like consul, etcd and SkyDNSare perfect for Service Discovery.
Adopting Microservices is not a free lunch. Steps to mitigate inherent complexity include distributed logging and MDC, microservices monitoring and stats, and reactive programming to coordinate async calls. The reactive call coordination would encompass what to do if there is a failure and what to do if a downstream service does not fail, but just times out or worse hangs.
User Experience and Microservices Monitoring
With Microservices which are released more often, you can try new features and see how they impact user usage patterns. With this feedback, you can improve your application. It is not uncommon to employ A/B testing and multi-variant testing to try out new combinations of features. Monitoring is more than just watching for failure. With big data, data science, and microservices, monitoring microservices runtime stats is required to know your application users. You want to know what your users like and dislike and react.
Debugging and Microservices Monitoring
Runtime statistics and metrics are critical for distributed systems. Since microservices architecture use a lot of remote calls. Monitoring microservices metrics can include request per second, available memory, #threads, #connections, failed authentication, expired tokens, etc. These parameters are important for understanding and debugging your code. Working with distributed systems is hard. Working with distributed systems without reactive monitoring is crazy. Reactive monitoring allows you to react to failure conditions and ramp of services for higher loads.
Circuit Breaker and Microservices Monitoring
You can employ the Circuit Breaker pattern to prevent a catastrophic cascade, and reactive microservices monitoring can be the trigger. Downstream services can be registered in a service discovery so that you can mark nodes as unhealthy as well react by reroute in the case of outages. The reaction can be serving up a deprecated version of the data or service, but the key is to avoid cascading failure. You don't want your services falling over like dominoes.
Cloud Orchestration and Microservices Monitoring
Reactive microservices monitoring would enable you to detect heavy load, and spin up new instances with the cloud orchestration platform of your choice (EC2, CloudStack, OpenStack, Rackspace, boto, etc.).
Continuously deployable services
The focus on Microservices is a focus on business capability, and a refocus on object oriented programming roots and organizing code around business domains with data and business rules co-located in the same process or set of processes.
The focus is on breaking up applications into small reusable services which might be useful to other services or other applications. The services can be deployed independently. This allows each of these services to be tweaked, and then redeployed independently. This is where the "micro" part of microservices comes into play. The services are small and independent. This is where microservices have been compared to Unix philosophy, they provide services that handle requests and give responses. Ken Thompson, Unix creator, said Unix has a philosophy of one tool, one job.
The Unix philosophy emphasizes building short, simple, clear, modular, and extendable code that can be easily maintained and repurposed by developers other than its creators.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
High performers are twice as likely to exceed organizational performance goals as low performers: profitability, productivity, market share, number of customers.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
High performers are twice as likely to exceed noncommercial performance goals as low performers: quantity of products/ services, operating efficiency, customer satisfaction, quality of products/services, achieving organizational/mission goals.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
In a follow-up survey to the initial 2014 data collection effort, we gathered stock ticker data and performed additional analysis on responses from just over 1,000 respondents across 355 companies who volunteered the organization they worked for. For those who worked for publicly traded companies, we found the following (this analysis was not replicated in later years because our dataset was not large enough): –High performers had 50% higher market capitalization growth over three years compared to low performers.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
The four measures of software delivery performance (deploy frequency, lead time, mean time to restore, change fail percentage) are good classifiers for the software delivery performance profile. The groups we identified—high, medium, and low performers—are all significantly different across all four measures each year. Our analysis of high, medium, and low performers provides evidence that there are no trade-offs between improving performance and achieving higher levels of tempo and stability: they move in tandem. Software delivery performance predicts organizational performance and noncommercial performance.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Lead time is highly correlated with version control and automated testing. MTTR is highly correlated with version control and monitoring. Software delivery performance is correlated with organizational investment in DevOps. Software delivery performance is negatively correlated with deployment pain. The more painful code deployments are, the poorer the software delivery performance and culture.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Unplanned work and rework: –High performers reported spending 49% of their time on new work and 21% on unplanned work or rework. –Low performers spend 38% of their time on new work and 27% on unplanned
work or rework. –There is evidence of the J-curve in our rework data. Medium performers spend more time on unplanned rework than low performers, with 32% of their time spent on unplanned work or rework. Manual work: –High performers report the lowest amount of manual work across all practices (configuration management, testing, deployments, change approval process) at statistically significant levels. –There is evidence of the J-curve again. Medium performers do more manual work than low performers when it comes to deployment and change approval processes, and these differences are statistically significant.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
BURNOUT AND DEPLOYMENT PAIN: Deployment pain is negatively correlated with software delivery performance and Westrum organizational culture. The five factors most highly correlated with burnout are Westrum organizational culture (negative), leaders (negative), organizational investment (negative), organizational performance (negative), and deployment pain (positive).
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Trunk-based development: –High performers have the shortest integration times and branch lifetimes, with branch life and integration typically lasting hours or a day. –Low performers have the longest integration times and branch lifetimes, with branch life and integration typically lasting days or weeks. Technical practices predict continuous delivery, Westrum organizational culture, identity, job satisfaction, software delivery performance, less burnout, less deployment pain, and less time spent on rework. High performers spend 50% less time remediating security issues than low performers.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
A loosely coupled, well-encapsulated architecture drives IT performance. In the 2017 dataset, this was the biggest contributor to continuous delivery.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
LEAN PRODUCT MANAGEMENT CAPABILITIES The ability to take an experimental approach to product development is highly correlated with the technical practices that contribute to continuous delivery. Lean product development capabilities predict Westrum organizational culture, software delivery performance, organizational performance, and less burnout.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.
Forsgren PhD, Nicole. Accelerate . IT Revolution Press. Kindle Edition.