End-to-End-Entwicklerworkflow
Verbinden Sie GitHub Actions CI/CD, Azure Container Registry, Container Apps und Application Insights zu einem vollständigen inneren Entwicklerkreislauf – vom Commit bis zur beobachtbaren Produktionsumgebung.
End-to-End-Entwicklerworkflow ist eine kostenlose Cloud & IT Cert Prep-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Cloud & IT Cert Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.
Der moderne Azure-Entwicklerworkflow
Ein moderner Azure-Entwicklerworkflow verbindet Quellcodeverwaltung, CI/CD, Containerinfrastruktur und Observability zu einer nahtlosen Inner Loop – vom Code-Commit bis zur beobachtbaren Produktionsumgebung. Die zentralen Komponenten sind: GitHub (Quelle), GitHub Actions (Build- und Bereitstellungspipeline), Azure Container Registry (Imagespeicher), Azure Container Apps (Laufzeitumgebung) und Application Insights (Observability). Jede Änderung gelangt innerhalb weniger Minuten automatisch vom Entwicklergerät in die Produktion, wobei in jedem Schritt Qualitätssicherungen greifen.
Schritt 1: Quellcodeverwaltung und Branching-Strategie
Organisieren Sie Ihren Code in einem GitHub-Repository und verwenden Sie eine trunk-basierte Entwicklungsstrategie oder GitFlow. Für die meisten Microservices reduziert die trunk-basierte Entwicklung (kurzlebige Feature-Branches, die täglich in main zusammengeführt werden) Integrationskonflikte und hält die Pipeline einfach. Verwenden Sie Branch-Schutzregeln für main, um vor dem Zusammenführen Reviews von Pull Requests und erfolgreich durchlaufene CI-Prüfungen zu verlangen. Eine CODEOWNERS-Datei stellt sicher, dass Änderungen an kritischen Diensten die Genehmigung der zuständigen Seniorentwickler des jeweiligen Teams erfordern.
# Example .github/CODEOWNERS
# Require payments-team review for any changes under /src/payments/
/src/payments/ @payments-team
/infrastructure/ @platform-teamSchritt 2: CI mit GitHub Actions
Die CI-Pipeline wird bei jedem Pull Request ausgeführt. Ein typischer Workflow sieht folgendermaßen aus: Code auschecken → Abhängigkeiten wiederherstellen → Komponententests ausführen → Integrationstests ausführen → Docker-Image erstellen → in Azure Container Registry pushen. Das Image wird zur Rückverfolgbarkeit mit dem Git-Commit-SHA getaggt. Verwenden Sie die OIDC-basierte Authentifizierung von GitHub Actions bei Azure (über eine föderierte Identität), um das Speichern von Geheimnissen für Azure-Dienstprinzipale in GitHub zu vermeiden – eine Entsprechung zur verwalteten Identität für CI-Pipelines.
# .github/workflows/ci.yml (abbreviated)
name: CI
on: [pull_request]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Login to ACR
uses: azure/docker-login@v1
with:
login-server: myacr.azurecr.io
username: ${{ secrets.AZURE_CLIENT_ID }}
password: ${{ secrets.AZURE_CLIENT_SECRET }}
- name: Build and push image
run: |
docker build -t myacr.azurecr.io/myapi:${{ github.sha }} .
docker push myacr.azurecr.io/myapi:${{ github.sha }}Schritt 3: CD in die Stagingumgebung
Nachdem die CI-Pipeline bei einem Merge in main erfolgreich war, stellt die CD-Pipeline automatisch in der Stagingumgebung bereit. Die Pipeline aktualisiert das Image-Tag der Container App auf den SHA des neu erstellten Images, wartet, bis die neue Revision fehlerfrei ist, und führt Smoke-Tests für die Staging-URL aus. Smoke-Tests prüfen, ob wichtige API-Endpunkte die erwarteten Antworten liefern. Schlagen die Smoke-Tests fehl, führt die Pipeline ein Rollback durch, indem sie den Ingress-Datenverkehr ohne manuellen Eingriff wieder auf die vorherige Revision umleitet.
# CD stage: update Container App to new image
- name: Deploy to staging
uses: azure/cli@v2
with:
azcliversion: latest
inlineScript: |
az containerapp update \
--name myapi-staging \
--resource-group myRG \
--image myacr.azurecr.io/myapi:${{ github.sha }}
- name: Run smoke tests
run: |
STAGING_URL=$(az containerapp show --name myapi-staging \
--resource-group myRG \
--query 'properties.configuration.ingress.fqdn' -o tsv)
curl -f https://$STAGING_URL/health || exit 1Schritt 4: Genehmigungsschranke für die Produktion
Nach der Validierung in der Stagingumgebung hält die CD-Pipeline an einer Genehmigungsschranke an. Mit den Umgebungsschutzregeln von GitHub Actions können Sie erforderliche Prüfer für die production-Umgebung konfigurieren. Die Pipeline sendet eine Slack-Benachrichtigung an den Bereitschaftsingenieur. Dieser prüft die Testergebnisse der Stagingumgebung, die Änderungen und alle offenen Vorfälle, bevor er die Genehmigung erteilt. Erst nach der Genehmigung fährt die Pipeline mit der Bereitstellung desselben Image-SHA in der Produktion fort. Dieser Schritt mit menschlicher Kontrolle ist für stark frequentierte oder regulierte Dienste entscheidend.
# In GitHub: create 'production' environment with required reviewers
# .github/workflows/cd.yml (abbreviated)
jobs:
deploy-production:
environment:
name: production
url: https://myapi.contoso.com
needs: deploy-staging
steps:
- name: Deploy to production
uses: azure/cli@v2
with:
inlineScript: |
az containerapp update \
--name myapi \
--resource-group myRG \
--image myacr.azurecr.io/myapi:${{ github.sha }}Schritt 5: Observability in der Produktion
Nach der Bereitstellung in der Produktion bietet Application Insights Einblick in Echtzeit. Das App-Insights-SDK (oder die automatische Instrumentierung für unterstützte Laufzeitumgebungen) erfasst: Anforderungsraten, Fehlerraten und Latenz (die drei Golden Signals), Abhängigkeitsaufrufe (an Datenbanken, Service Bus und andere APIs) sowie Ausnahmen mit vollständigen Stacktraces. Die Application Map visualisiert, wie Dienste einander aufrufen, und hebt hervor, welche Abhängigkeiten am stärksten zu Fehlern oder Latenz beitragen.
# Python: Add Application Insights SDK
from opencensus.ext.azure.log_exporter import AzureLogHandler
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.trace.samplers import ProbabilitySampler
from opencensus.trace.tracer import Tracer
tracer = Tracer(
exporter=AzureExporter(connection_string='InstrumentationKey=<key>'),
sampler=ProbabilitySampler(1.0)
)Bereitstellungen mit Traces verknüpfen
Verwenden Sie Application Insights Annotations, um Bereitstellungsereignisse in Ihren Metrikdiagrammen zu markieren. Wenn eine Release-Annotation erstellt wird (über die GitHub-Actions-Aktion azure/appinsights-annotation), erscheint sie als vertikale Linie in allen App-Insights-Metrikdiagrammen. Dadurch ist sofort erkennbar, ob ein Latenzanstieg oder eine erhöhte Fehlerrate mit einer kürzlich erfolgten Bereitstellung zusammenhängt. Das verkürzt die mittlere Zeit bis zur Diagnose (MTTD) während Vorfällen erheblich.
# Create a release annotation in Application Insights
- name: Annotate release in App Insights
uses: azure/appinsights-annotation@v1
with:
appInsightsResourceName: myAppInsights
resourceGroupName: myRG
releaseName: '${{ github.run_id }}-${{ github.sha }}'Automatisches Rollback bei einem Anstieg der Fehlerrate
Für besonders ausfallsichere Pipelines sollten Sie ein automatisches Rollback implementieren. Nach der Bereitstellung in der Produktion wartet die Pipeline 10 Minuten und fragt Application Insights nach der Fehlerrate ab. Überschreitet die Fehlerrate einen konfigurierbaren Schwellenwert (z. B. >5 %), führt die Pipeline automatisch ein Rollback durch, indem sie den Ingress-Datenverkehr der Container App zu 100 % auf die vorherige Revision umleitet. Dieses Muster der progressiven Bereitstellung begrenzt die Auswirkung einer fehlerhaften Bereitstellung und ermöglicht Teams auch bei komplexen oder sensiblen Änderungen eine sichere Bereitstellung.
# Query App Insights error rate via REST (abbreviated)
QUERY='requests | where timestamp > ago(10m) | summarize failed = countif(success == false), total = count() | extend errorRate = round(100.0 * failed / total, 2)'
RESULT=$(az monitor app-insights query \
--apps myAppInsights \
--resource-group myRG \
--analytics-query "$QUERY" \
--query 'tables[0].rows[0][2]' -o tsv)
if [ $(echo '$RESULT > 5' | bc -l) -eq 1 ]; then
echo 'Error rate $RESULT% - rolling back!'
az containerapp ingress traffic set --name myapi --resource-group myRG --revision-weight stable=100
fiEntwicklerproduktivität: Lokale Entwicklung mit Emulatoren
Entwickler sollten den gesamten Stack lokal ausführen und testen können, ohne eine Verbindung zu Azure-Produktionsressourcen herzustellen. Verwenden Sie Azure Storage Emulator (Azurite) für die lokale Blob- und Warteschlangenspeicherung, den Cosmos DB Emulator für lokale Datenbanktests und den Service Bus Emulator für lokale Nachrichtenübermittlung. Die Umgebungsvariable AZURE_ENVIRONMENT=local kann DefaultAzureCredential so umschalten, dass Verbindungszeichenfolgen für Emulatoren verwendet werden, während derselbe Code in Azure eine verwaltete Identität nutzt. Docker Compose orchestriert alle lokalen Abhängigkeiten mit einem einzigen docker compose up.
# docker-compose.yml for local development
services:
azurite:
image: mcr.microsoft.com/azure-storage/azurite
ports:
- '10000:10000'
- '10001:10001'
cosmos-emulator:
image: mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator
ports:
- '8081:8081'Sicherheit im Entwicklerworkflow
Integrieren Sie Sicherheit in jede Phase des Entwicklerworkflows: Dependabot sucht in Pull Requests nach anfälligen Abhängigkeiten; GitHub Advanced Security (Codescanning mit CodeQL) erkennt Schwachstellen wie SQL-Injection und fest codierte Geheimnisse; Microsoft Defender for DevOps lässt sich in GitHub integrieren, um Azure-Sicherheitsempfehlungen neben Codeänderungen anzuzeigen; und das ACR Defender-Schwachstellenscanning prüft Container-Images nach jedem Push auf CVEs in Betriebssystem und Anwendungsschicht. Sicherheitsergebnisse werden als Kommentare in Pull Requests angezeigt und können daher vor dem Zusammenführen behoben werden.
Alles zusammenführen
Der vollständige Entwicklerworkflow ist eine kontinuierliche Feedbackschleife: Ein Entwickler führt einen Code-Commit durch, CI erstellt und testet das Container-Image, das Image wird mit dem Commit-SHA als Tag in ACR gepusht, CD stellt es in der Stagingumgebung bereit und führt Smoke-Tests aus, ein Mensch genehmigt die Bereitstellung in der Produktion, die Pipeline stellt das Image in der Produktion bereit und erstellt eine Release-Annotation, und Application Insights überwacht die Fehlerraten mit automatischem Rollback, wenn Schwellenwerte überschritten werden. Infrastructure as Code (Bicep oder Terraform) im selben Repository stellt sicher, dass Pipeline, Container App und Überwachungskonfiguration zusammen mit dem Anwendungscode versionskontrolliert werden.
Schnelltest
Testen Sie Ihr Verständnis der Konzepte aus Microsoft Azure Fundamentals (AZ-900), die in dieser Lektion behandelt wurden.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Der End-to-End-Entwicklerworkflow verbindet die Quellcodeverwaltung mit GitHub, GitHub Actions CI/CD, Azure Container Registry, Container Apps und Application Insights; Release-Annotationen setzen Bereitstellungen mit Metrikänderungen in Beziehung und ermöglichen so eine schnellere Diagnose von Vorfällen; und ein automatisches Rollback auf Grundlage von Fehlerratenabfragen verringert die Auswirkungen fehlerhafter Bereitstellungen. Als Nächstes beginnen wir mit der Prüfungsvorbereitung und einer umfassenden Wiederholung von Cloudkonzepten und Azure-Architektur.
Häufig gestellte Fragen
Ist die Lektion „End-to-End-Entwicklerworkflow“ kostenlos?
Ja — der vollständige Text von „End-to-End-Entwicklerworkflow“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Cloud & IT Cert Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „End-to-End-Entwicklerworkflow“?
Verbinden Sie GitHub Actions CI/CD, Azure Container Registry, Container Apps und Application Insights zu einem vollständigen inneren Entwicklerkreislauf – vom Commit bis zur beobachtbaren Produktions… Du übst Cloud & IT Cert Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Cloud & IT Cert Prep zu starten?
Keine Vorkenntnisse erforderlich. Cloud & IT Cert Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „End-to-End-Entwicklerworkflow“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Cloud & IT Cert Prep-Lektion Code schreiben und ausführen?
Ja. Jede Cloud & IT Cert Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Verwaltete Identität für kennwortlose Authentifizierung
- Azure Service Bus für entkoppelte Nachrichtenübermittlung
- Azure Container Apps
- End-to-End-Entwicklerworkflow