Microservices Design & Architecture

Tuesday, October 27, 2020

- PDT
PRO WORKSHOP (MICROSERVICES): Streaming Microservices Architecture with Apache Kafka, Kubernetes and Istio Service Mesh
Join on Hopin
Kai Waehner
Kai Waehner
Confluent, Technology Evangelist

Apache Kafka became the de facto standard for microservice architectures. It goes far beyond reliable and scalable high-volume messaging. In addition, you can leverage Kafka Connect for integration and the Kafka Streams API for building lightweight stream processing microservices in autonomous teams. However, microservices also introduce new challenges like observability of the whole ecosystem.

A Service Mesh technology like Istio (including Envoy) complements the architecture. It describes the network of microservices that make up such applications and the interactions between them. Its requirements can include discovery, load balancing, failure recovery, metrics, and monitoring. A service mesh also often has more complex operational requirements, like A/B testing, canary rollouts, rate limiting, access control, and end-to-end authentication.

This session explores the problems of distributed Microservices communication and how both Apache Kafka and Service Mesh solutions address it together on top of Kubernetes. I cover different approaches for combining both to build a reliable and scalable microservice architecture with decoupled and secure microservices.

- PDT
PRO WORKSHOP (MICROSERVICES): Split Your Monolith to Microservices with Feature Flags
Join on Hopin
Joy Ebertz
Joy Ebertz
Split.io, Senior Staff Software Engineer

In a typical monolithic application, you have a large application talking to a large database. In a microservices architecture, instead of building a large application, we build a number of smaller applications, known as microservices, which exchange messages among themselves. While the process of migrating from a monolith to microservices can be tricky, we will examine why you would want to make this change, the challenges of this migration, how feature flags solve those challenges, and best practices to tie it all together.

- PDT
PRO WORKSHOP (MICROSERVICES): Developing While There Are Hundreds of Microservices Around You Without Breaking Your APIs
Join on Hopin
Michael Haberman
Michael Haberman
Aspecto, CTO & Co-Founder

Managing dozens or hundreds of microservices in scale can be very challenging. As developers, we often find ourselves blind to how our application is actually behaving in production, what dependencies we should be aware of and what should we check before deploying a new version.

In this talk, we will introduce how to leverage tracing capabilities in production during development & testing phases to improve our code.

- PDT
PRO WORKSHOP (MICROSERVICES): Business Value of App Modernization Through Containers
Join on Hopin
Sunil Joshi
Sunil Joshi
IBM, CTO, Cloud Application Services

Application modernization for higher agility and cost optimization has become table stakes for enterprises to be competitive. One of the most common patterns to accomplish that is through containerization. Container platforms have become an integral part of any Hybrid Cloud IT landscape. They accelerate the multi cloud adoption in enterprises. Containers can be deployed in any cloud (IBM, AWS, Azure, Google) or on-premise. In fact, most of the public clouds have Container platforms as Service.
The question, what are the relevant KPIs and measures to keep in mind when moving from a traditional development to the container world. How do you know your App modernization strategy through containers is working? This session will discuss these questions and others to provoke thinking among the business and technical executives

- PDT
PRO WORKSHOP (MICROSERVICES): Observable Microservices make Monitoring Simple
Join on Hopin
Kayalvizhi Kandasamy
Kayalvizhi Kandasamy
Imaginea Technologies, Principal Software Architect

Microservices is not a buzz word but Observability is.
The session details the observability needs of building distributed systems followed by a workshop covering the below.

1. Building Observable Spring Boot Java Microservices by adding Resilience patterns (Circuit Breaker, Retry, Rate-limiting etc...) using Resilence4j
2. Enabling them for Event Driven
3. Adding Actuator for exposing metrics
4. Monitoring using Prometheus
5. Alerting using Prometheus Alert Manager
6. Tracing using Zipkin

Thursday, October 29, 2020

- PDT
PRO SESSION (MICROSERVICES): Waking up in the Weeds of Microservices? How to Diagnose Your First Bug
Join on Hopin
Muktesh Mishra
Muktesh Mishra
Adobe, Senior Software Engineer

You invest your time and effort breaking up that monolithic Frankenstein into a suite of elegant composable micro-services, you containerize them and you deploy them somewhere in the cloud. Then you proudly watch it all come together reaping the benefits of the most scalable architectures. It is all fine and dandy from this point on. Too good to be true? Of course! This session is about what to do when you wake up to find yourself in the weeds diagnosing that first bug and tracing calls through the convoluted web of micro-services of your own doing. Through a series of demos and code snippets, we will introduce the most important open-source projects tools to strike the right balance of monitoring at the infrastructure, container, and services.

- PDT
PRO WORKSHOP (MICROSERVICES): Why GraphQL Between Services Is the Worst Idea and the Best Idea at the Same Time
Join on Hopin
Uri Goldshtein
Uri Goldshtein
The Guild, Founder

It seems like everyone is talking about GraphQL. "GraphQL all the things!!". But does GraphQL really fits everywhere? What might be some of the issues of using GraphQL between services?

In this talk I will demonstrate different approaches that are currently being discussed in the community, their downsides and pitfalls and also reveal a new radical approach that might shine a new light on the subject, using the "GraphQL Mesh" library

- PDT
PRO WORKSHOP (MICROSERVICES) : Automatic Microservices Observability With Ballerina
Join on Hopin
Anjana Fernando
Anjana Fernando
WSO2, Director of Developer Relations

Modern applications are increasingly becoming more of a distributed computing problem. With the availability of feature rich cloud services, our solutions are increasingly relying on these in implementing functionality. Also, the application itself is adopting more of a disaggregated architecture in favor of extensibility, scalability, re-usability, and deployment flexibility. This is how microservices architectures are becoming popular everyday. But there is no free lunch; with the benefits, there are new challenges that are introduced. Compared to monoliths, with microservices we need to handle the complexities that come with networked architectures, such as communication latency, unreliable connections, protocols, data formats, and transactions. So while we come up with many new techniques to tackle these problems, it’s vital for us to have a proper observability functionality to verify the behavior. The Ballerina programming, which is designed from ground-up to work with networked applications, takes in a unique approach by having built-in observability functionality in language constructs. It exploits the language awareness for network operations, such as service types, remote function invocations, communication resiliency mechanisms, to automatically observe the operations done by the users. Basically the Ballerina platform takes care of the majority observability situations automatically, so the developer can only focus on the core business logic, and not sprinkle your code with lots of observability code. In this session, we will look at these features on how these built-in functionality will be used for metrics generation and distributed tracing using the Ballerina platform.

- PDT
(MICROSERVICES): Beyond the Container – Making Microservices Portable
Join on Hopin
David Thor
David Thor
Architect.io, Founder & CEO

Containerization gave applications portability from local dev to production, but in our pursuit of service-oriented design that portability has been lost. This talk will discuss how we can build upon containerization to make complex services portable through dependency management and resolution.