DP-420T00: Designing and Implementing Cloud-Native Applications Using Microsoft Azure Cosmos DB

Das Training richtet sich an Azure Entwickler und Software Architects, welche einen Überblick über die Kernelemente der Entwicklung von Cloud Native Applications in Microsoft Azure bekommen wollen.

Physisch oder virtuell?

Nehmen Sie an einem unserer Standorte Frankfurt, München und Wien oder virtuell an unseren Klassenraumtrainings teil. Unter “Termin buchen” werden Ihnen alle Optionen angezeigt, zuerst sortiert nach Standort, dann nach Datum.

Trainingsteilnehmer, welche die Labs erfolgreich durchführen wollen, sollten Kenntnisse und Erfahrung der in AZ-204 vermittelten Kenntnisse erworben haben. Mit RECAP gekennzeichnete Themen sind Kurzzusammenfassungen von AZ-204 Inhalten als Refresher. DevSecOps relevante Themen werden in einem separatem Kurs behandelt.
Azure Developers & Software Architects

Wichtige Information

Dieses Training behandelt prüfungsrelevante Themen zum Examen: Microsoft Certified: Azure Cosmos DB Developer Specialty

Was werden Sie in diesem Training erlernen?

Begleitend zu den Theorieteilen der einzelnen Module, modernisieren wir eine App bestehend aus klassischem Monolithen in eine Cloud Native App mit Microservices (Catalog, State, Payment, Delivery, Purchasing) und Micro Frontends um. Dabei legen wir Wert auf die Verwendung von Best Practices und Cloud Design Patterns, sowie deren Abbildung mit Software Architektur Diagrammen. Wir vermitteln die Container Essentials, und Konzepte wie Stateful Containers oder SideCar Pattern und besprechen im Detail mögliche Refactorings bezüglich Bereitstellung in den Kubernetes basierenden Azure Container Apps und behandeln dabei Themen wie Secrets, Revisions, Config Injection, Health Checks, Kubernetes Event Driven Auto-Scaling – KEDA. Dem Prinzip von Domain Driven Design folgend, vermitteln wir die Vorteile von NoSQL Datenbanken und begleiten Sie auf Ihrem Weg von Relational DB Design zum Cosmos DB NoSQL Api. Dabei behandeln wir auch die Themen Change Feed, Event Sourcing und CQRS. Wir vermitteln die Grundlagen von Event Driven Applications, deren Transaktionsmustern, die wir mittels Saga Pattern implementieren und verbinden die einzelnen Services mittels Distributed Application Runtime (Dapr). Wir nutzen Durable Functions, um Microservices zu implementieren, welche wahlweise Serverless aber auch also Container gehostet werden können. Im Speziellen gehen wir hier auf die Themen Durable Entities, Durable Monitoring und Durable Saga Pattern ein. Last but not least publizieren und sichern wir die App, und deren Microservices mit API Management und Application Gateway, um dann noch unser Reactive Angular UI mit Client Side State in Echtzeit mittels Azure Web PubSub aktuell zu halten. In allen Phasen werden auch Aspekte von Authentication und Authorization mittels Microsoft Identity besprochen. Die Provisionierung der einzelnen Ressourcen wird der Flexibilität und dem GitOps Prinzipien folgend währen der einzelnen Module über Azure CLI entwickelt. Beispiele werden größtenteils in .NET, Angular und React implementiert. Fallweise können aber auch alternative Technologie Stacks (Spring Boot) verwendet werden, bzw. wird auf deren Docs verwiesen.

Agenda

Introduction to Cloud Native Applications
Recap: Building Blocks & Architecture Overview
Implementing Reactive Micro Frontends using Azure Web Pub / Sub
Optimizing and Securing API Access using Api Management
Connecting Microservices using Distributed Application Runtime - Dapr
Designing & Implementing Event Driven Apps
Introduction to Azure Container Apps (ACA) and Kubernetes Event-Driven Autoscaling (KEDA)
Implementing Microservices using Durable Azure Functions
Schema-less and Event Optimized Data storage using Cosmos DB
Container Essentials: Optimizing Services & Front Ends
Introduction to Cloud Native Applications
What are Cloud Native Applications
App Monolith vs Microservices
Domain Driven Design (DDD) and Bounded Context Pattern
Microservices Communication Patterns (Sync, Async, Event Driven)
Api Gateway Pattern, Frontend Aggregation Pattern
What are Event Driven Applications
What are Cloud Architecture Design Patterns
Creating Software Architecture Diagrams
Recap: Building Blocks & Architecture Overview
Hosting: Containers, Kubernetes and Functions (Serverless / Containers)
Storage: Azure Cosmos DB, Azure SQL, Blob Storage
Configuration Management, Secrets: Key Vault, App Config Service
Messaging Brokers: Service Bus, Event Hub, Event Grid
Real Time: Azure SignalR Service, Azure Web PubSub
Access & Management: API Management & Application Gateway
Authentication & Authorization: Microsoft Identity & Managed Identities
Container Essentials & Patterns
Azure Container Hosts: Azure Container Apps vs Kubernetes
Understanding and using Sidecar Pattern
Stateful Containers using Azure Blob Storage and Volume Mounts
Using docker-compose.yaml to locally test multiple containers
Docker Development Workflow and Debugging
Configuration Management Options (Env Variables, ConfigMaps, Azure App Config Service)
Container Recap (Multistage Build, Run, Debug, Publish to ACR)
Schemaless and Event Optimized Data storage using Cosmos DB
Cosmos DB Change Feed and Event Sourcing
Cosmos DB Partitioning Strategies
From Relational to Schemaless: Does and Don'ts
Implementing Domain Driven Design for microservices
Understanding and implementing the CQRS Pattern
Implementing Microservices using Durable Azure Functions
Hosting and Scaling Function Apps in Containers
Durable Functions and Patterns
Container Apps Monitoring and Logging (Observability)
Container Apps Authentication and Authorization using Managed Identities
Working with Revisions
Introduction to KEDA (Kubernetes Event Driven Auto-Scaling)
Working with Secrets
What is Azure Container Apps
Implementing OData and Open API Support
Hosting: Serverless vs Containers
Serverless and Azure Functions Recap
Using Azure Durable Entities for Long running processes and background Tasks
Deploying a muliti-container App (Ingress, Exgress)
Monitoring Durable Functions
Implementing a Microservice using Azure Durable Functions
Implementing a Saga Pattern using Durable Functions
Changing Storage Providers in Azure Durable Functions
Designing & Implementing Event Driven Apps
Common Message Broker Types in Azure
Messages vs Events
Introduction to Event Driven Architecture
Message Patterns: Queues vs Topics (Pub/Sub)
What to choose when: Service Bus vs Event Hub vs Event Grid
Choosing the Messaging Broker: Features and Use-Cases
Common Cloud Design Patterns used with Even Driven Architecture
Event Sourcing and Integration Events
Publishing & Subscribing Event in Microservices
Implementing Transactions using the Saga Pattern
Orchestration vs Choreography
Refactor Microservices to support Event Based Communication
Debugging Event Driven Applications
Connecting Microservices using Distributed Application Runtime (Dapr)
Understanding Dapr Pub/Sub
Using Dapr Components to interact with Azure Services
Enhance Performance using Dapr State Management
Understanding Dapr Architecture
Dapr Environment Setup & Tooling
Introduction to Dapr
Optimizing and Securing API Access using Api Management
APIM Policies Recap (Quotas, Throttling, Mock Response, Retry, ...)
API Management (APIM) Recap
Understanding Gateway Pattern and Backends for Frontends Pattern
API Versions and Revisions
Securing API Access using Authentication & Managed Identities-
Using Redis Cache in API Management
Intro to GraphQL and Use Cases
Introduction to APIM Synthetic GraphQL
Implementing Real Time Micro-Frontends & User Interfaces
Implementing a Micro Frontend as Teams App.
Implementing Reactive Real Time Frontends using Event Grid & Azure Web PubSub
Introduction to Micro Frontends
Real Time Options: SignalR vs Azure Web PubSub
Event Grid Recap

Dein Training im Überblick

Dauer 4
Trainingssprache Deutsch
Trainingsart brainyCLASS (offen)

2.715,00 

Startdatum und Ort wählen

Terminübersicht