Manuelles Bereitstellen Ihrer cloudeigenen App in Azure Kubernetes Service

  • 8 Minuten

Bevor Sie Ihre Websitebereitstellungen automatisieren können, müssen Sie die vorhandene eShop-App manuell in Azure Kubernetes Service (AKS) bereitstellen. Sie erstellen die Azure-Ressourcen und stellen die App mithilfe von Azure CLI-Befehlen und Bash-Skripts in AKS bereit. Anschließend erstellen Sie einen Azure Active Directory (Azure AD)-Dienstprinzipal, damit GitHub-Aktionen in AKS und Azure Container Registry bereitgestellt werden können.

Mit den Befehlen werden die folgenden Ressourcen erstellt, um eine aktualisierte Version der eShop-App bereitzustellen.

  • Stellen Sie eine Azure Container Registry (ACR) bereit, und übertragen Sie dann Bilder in die Registrierung.
  • Erstellen Sie einen AKS-Cluster und setzen Sie dann die Container im Cluster ein.
  • Testen Sie die Bereitstellung.
  • Erstellen Sie Dienstprinzipale, damit GitHub-Aktionen in der AKS- und Azure-Containerregistrierung bereitgestellt werden können.

Von Bedeutung

Stellen Sie sicher, dass Sie die Voraussetzungen abgeschlossen haben, bevor Sie beginnen.

Öffnen Sie die Entwicklungsumgebung

Sie können einen GitHub-Codespace als Host für die Übung verwenden oder sie lokal in Visual Studio Code durchführen.

Einrichtung von GitHub Codespaces

Forken Sie das https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops Repository auf Ihr eigenes GitHub-Konto. Tun Sie dann auf Ihrer neuen Fork Folgendes:

  1. Wählen Sie "Code" aus.
  2. Wählen Sie die Registerkarte Codespaces aus.
  3. Wählen Sie das + Symbol aus, um Ihren Codespace zu erstellen.

GitHub dauert mehrere Minuten, um den Codespace zu erstellen und zu konfigurieren. Nach Abschluss des Vorgangs werden die Codedateien für die Übung angezeigt.

Optional: Visual Studio Code-Setup

Um Visual Studio Code zu verwenden, verzweigen Sie das https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops Repository auf Ihr eigenes GitHub-Konto, und klonen Sie es lokal. Führen Sie dann folgende Schritte aus:

  1. Installieren Sie alle Systemanforderungen, um Dev Container in Visual Studio Code ausführen zu können.
  2. Achten Sie darauf, dass Docker ausgeführt wird.
  3. Öffnen Sie in einem neuen Visual Studio Code-Fenster den Ordner des geklonten Repositorys
  4. Drücken Sie STRG+UMSCHALT+P , um die Befehlspalette zu öffnen.
  5. Suche: >Dev-Container: In Container neu erstellen und erneut öffnen
  6. Visual Studio Code erstellt Ihren Entwicklungscontainer lokal.

Erstellen von Containern

  1. Führen Sie im Terminalbereich den folgenden Dotnet CLI-Befehl aus:

    dotnet publish /p:PublishProfile=DefaultContainer

Erstellen der Azure-Ressourcen

  1. Melden Sie sich im Terminalbereich mit diesem Azure CLI-Befehl bei Azure an:

    az login --use-device-code

  2. Zeigen Sie das ausgewählte Azure-Abonnement an.

    az account show -o table

    Wenn das falsche Abonnement ausgewählt ist, verwenden Sie den Befehl "az account set ", um das richtige Abonnement auszuwählen.

  3. Führen Sie den folgenden Azure CLI-Befehl aus, um eine Liste der Azure-Regionen und den damit verbundenen Namen abzurufen:

    az account list-locations -o table

    Suchen Sie eine Region, die Ihnen am nächsten liegt, und verwenden Sie sie im nächsten Schritt, indem Sie [Closest Azure region] ersetzen.

  4. Führen Sie die folgenden Bash-Anweisungen aus:

    export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM

    Die vorherigen Befehle erstellen Umgebungsvariablen, die Sie in den nächsten Azure CLI-Befehlen verwenden. Sie müssen den STANDORT in eine Azure-Region in Ihrer Nähe ändern, wie eastus. Wenn Sie einen anderen Namen für Ihre Ressourcengruppe, ihren AKS-Cluster oder ACR wünschen, ändern Sie diese Werte. Um Ihre neuen Repositorys im Azure-Portal anzuzeigen, weisen Sie sich selbst als App-Complianceautomatisierungs-Administrator in der Zugriffssteuerung (IAM) der Containerregistrierung zu.

  5. Führen Sie die folgenden Azure CLI-Befehle aus:

    az group create --name $RESOURCE_GROUP --location $LOCATION
az acr create --resource-group $RESOURCE_GROUP --name $ACR_NAME --sku Basic
az acr login --name $ACR_NAME

    Wenn beim Ausführen ein Authentifizierungsfehler az acr login --name $ACR_Name angezeigt wird, müssen Sie den Administratorbenutzer im neu erstellten Containerregister in Azure unter "Einstellungen – Zugriffstasten" aktivieren. Azure fordert Sie auf, diese Anmeldeinformationen einzugeben, um fortzufahren. Möglicherweise müssen Sie sich auch bei az login --use-device-code erneut authentifizieren.

    Mit diesen Befehlen wird eine Ressourcengruppe erstellt, die die Azure-Ressourcen, ein ACR für Ihre Bilder enthält und sich dann bei der ACR anmeldet. Es kann einige Minuten dauern, bis diese Ausgabe angezeigt wird:

      ...
  },
  "status": null,
  "systemData": {
    "createdAt": "2023-10-19T09:11:51.389157+00:00",
    "createdBy": "",
    "createdByType": "User",
    "lastModifiedAt": "2023-10-19T09:11:51.389157+00:00",
    "lastModifiedBy": "",
    "lastModifiedByType": "User"
  },
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries",
  "zoneRedundancy": "Disabled"
}
Login Succeeded

  6. Führen Sie die folgenden Befehle aus, um Ihre Bilder zu markieren und an die von Ihnen erstellte ACR zu übertragen:

    docker tag store $ACR_NAME.azurecr.io/storeimage:v1
docker tag products $ACR_NAME.azurecr.io/productservice:v1

docker push $ACR_NAME.azurecr.io/storeimage:v1
docker push $ACR_NAME.azurecr.io/productservice:v1

    Sie können überprüfen, ob das Hochladen der Bilder erfolgreich abgeschlossen wurde, indem Sie diesen Befehl ausführen:

    az acr repository list --name $ACR_NAME --output table

  7. Erstellen Sie Ihre AKS und verbinden Sie sie mit dem ACR mit diesen Befehlen:

    az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --node-count 1 --generate-ssh-keys --node-vm-size Standard_B2s --network-plugin azure --attach-acr $ACR_NAME

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

    Mit den Befehlen wird ein einzelner Knoten-AKS-Cluster erstellt, mit dem ACR verbunden und anschließend der lokale Computer mit dem AKS-Cluster verbunden. Die Befehle können einige Minuten benötigen, um abgeschlossen zu werden.

  8. Überprüfen Sie, ob die neuen AKS Bilder aus dem ACR mit diesem Befehl abrufen können:

    az aks check-acr --acr $ACR_NAME.azurecr.io --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

    Es sollte eine ähnliche Ausgabe wie die folgenden Nachrichten angezeigt werden:

    [2023-10-19T13:33:09Z] Loading azure.json file from /etc/kubernetes/azure.json
[2023-10-19T13:33:09Z] Checking managed identity...
[2023-10-19T13:33:09Z] Cluster cloud name: AzurePublicCloud
[2023-10-19T13:33:09Z] Kubelet managed identity client ID: 00001111-aaaa-2222-bbbb-3333cccc4444
[2023-10-19T13:33:09Z] Validating managed identity existance: SUCCEEDED
[2023-10-19T13:33:09Z] Validating image pull permission: SUCCEEDED
[2023-10-19T13:33:09Z] 
Your cluster can pull images from acseshop1251599299.azurecr.io!

    Sie können nun kubectl-Befehle für Ihren neuen AKS-Cluster ausführen. Kopieren Sie die vollständige ACR-URL aus der Ausgabe; Beispielsweise ist die obige URL acseshop1251599299.

  9. Überprüfen Sie den Status Ihres AKS-Clusters:

    kubectl get nodes -A

    Es sollte eine ähnliche Ausgabe wie die folgenden Nachrichten angezeigt werden:

    NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-37200563-vmss000000   Ready    agent   3h44m   v1.26.6

Konfigurieren des Kubernetes-Bereitstellungsmanifests

Jetzt befinden sich die eShop-Images im ACR, sie können das AKS-Bereitstellungsmanifest aktualisieren, um diese neuen Images zu verwenden.

  1. Wählen Sie in Visual Studio Code oder Codespaces im EXPLORER-Bereich die deployment.yml Datei im Stammverzeichnis des Projekts aus.

  2. Ersetzen sie in Zeile 17:

    - image: [replace with your ACR name].azurecr.io/storeimage:v1

    Fügen Sie den kopierten ACR-Namen aus dem vorherigen Schritt ein – die Zeile sollte ähnlich wie die folgende Yaml aussehen:

    - image: acseshop1251599299.azurecr.io/storeimage:v1

  3. Wiederholen Sie die folgenden Schritte für Zeile 65:

    - image: [replace with your ACR name].azurecr.io/productservice:v1

    Speichern Sie die Datei mit STRG+S.

  4. Stellen Sie im Terminalbereich einen NGINX-Eingangscontroller mit dem folgenden Kubernetes-Befehl bereit:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.3/deploy/static/provider/cloud/deploy.yaml

    Der kubectl Befehl fügt Dienste und Komponenten hinzu, um den Einstieg in Ihren AKS-Cluster zu ermöglichen. Überprüfen Sie, ob der Eingangsschritt mit dem folgenden Kubernetes-Befehl ausgeführt werden kann:

    kubectl get services --namespace ingress-nginx

    Es sollte eine ähnliche Ausgabe wie die folgenden Nachrichten angezeigt werden:

    NAME                                 TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.0.135.51    20.26.154.64   80:32115/TCP,443:32254/TCP   58s
ingress-nginx-controller-admission   ClusterIP      10.0.137.137   <none>         443/TCP                      58s

  5. Stellen Sie die eShop-App mit diesem Befehl bereit:

    kubectl apply -f deployment.yml

    Der kubectl apply-Befehl stellt die eShop-App bereit: eine Frontend-Blazor-Web-App, einen Backend-REST-API-Produktdienst und eine Eingangsregel, um den Datenverkehr an die richtigen Dienste in Ihrem AKS-Cluster weiterzuleiten. Führen Sie diesen Befehl erneut aus, wenn bei Bereitstellungen Fehler angezeigt werden.

    Es sollte eine ähnliche Ausgabe wie die folgenden Nachrichten angezeigt werden:

    deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created

  6. Überprüfen Sie, ob die beiden Microservices mit diesem Befehl bereitgestellt werden:

    kubectl get pods -A

    Es sollte eine ähnliche Ausgabe wie die folgenden Nachrichten angezeigt werden:

    NAMESPACE       NAME                                        READY   STATUS      RESTARTS   AGE
default         productservice-7569b8c64-vfbfz              1/1     Running     0          3m56s
default         storeimage-6c7c999d7c-zsnxd                 1/1     Running     0          3m56s
ingress-nginx   ingress-nginx-admission-create-szb8l        0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-admission-patch-czdbv         0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-controller-58bf5bf7dc-nwtsr   1/1     Running     0          4m4s

  7. Zeigen Sie den bereitgestellten eShop mit diesem Befehl an:

    echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"

    Der Befehl gibt die externe IP-Adresse für die Web-App zurück. Halten Sie STRG gedrückt, und klicken Sie auf den Link, um die App auf einer neuen Registerkarte zu öffnen.

    Screenshot der Startseite der eShop-Web-App.

Erstellen eines Dienstprinzipals für die Bereitstellung von GitHub

GitHub-Aktionen können Containerimages in einer Azure-Containerregistrierung veröffentlichen. Der GitHub-Runner muss daher über Berechtigungen zum Herstellen einer Verbindung mit Azure verfügen. Die folgenden Schritte erstellen einen Azure AD-Dienstprinzipal, der als GitHub Actions-Identität in Azure fungiert.

  1. Um Ihre Abonnement-ID in einer Umgebungsvariable zu speichern, führen Sie den folgenden Befehl im Terminal aus:

    export SUBS=$(az account show --query 'id' --output tsv)

  2. Führen Sie den folgenden Befehl aus, um einen Azure AD-Dienstprinzipal zu erstellen, um den Zugriff von GitHub zu ermöglichen:

    az ad sp create-for-rbac --name "eShop" --role contributor --scopes /subscriptions/$SUBS/resourceGroups/$RESOURCE_GROUP --json-auth

    Eine Variation der folgenden Ausgabe wird angezeigt:

    Creating 'Contributor' role assignment under scope '/subscriptions/ffffffff-aaaa-bbbb-6666-777777777777'

The output includes credentials that you must protect. Be sure that you do not include these credentials in your code or check the credentials into your source control. For more information, see https://aka.ms/azadsp-cli
 {
  "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "clientSecret": "abc1A~abc123ABC123abc123ABC123abc123ABC1",
  "subscriptionId": "00000000-0000-0000-0000-000000000000",
  "tenantId": "00000000-0000-0000-0000-000000000000",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"
}

  3. Kopieren Sie die JSON-Ausgabe und die Klammern, die im nächsten Schritt verwendet werden sollen.

Erstellen der GitHub-Geheimnisse

Der GitHub Actions runner verwendet Anmeldeinformationen für die Interaktion mit der Containerregistrierung und AKS. Der Dienstprinzipal und die Anmeldeinformationen für die Containerregistrierung sind vertrauliche Informationen. Es ist am besten, vertrauliche Informationen als verschlüsselte Geheimschlüssel an einem sicheren Ort zu speichern. GitHub bietet einen integrierten Speicherort zum Speichern von geheimen Schlüsseln und anderen Variablen.

Führen Sie die folgenden Schritte aus, um die vertraulichen Informationen sicher als Umgebungsvariablen in Ihrem Repository zu speichern. Repositoryadministratoren sollten die geheimnisse verwalten, auf die der GitHub Actions runner zugreifen kann.

  1. Gehen Sie in Ihrem geforktem GitHub-Repository zu Settings>Secrets and variables>Actions.

  2. Wählen Sie auf der Actions secrets and variables Seite New repository secret aus.

  3. Geben Sie auf der New secret Seite unter Name:AZURE_CREDENTIALS und unter Secret die JSON-Ausgabe ein, die Sie aus dem Terminal kopiert haben.

    Die Einstellungen sollten dem folgenden Screenshot ähneln:

    Screenshot der Seite

  4. Wählen Sie Add secretaus.

Sie verwenden diesen GitHub-Geheimschlüssel im nächsten Abschnitt, um eine GitHub-Aktion zum Erstellen des Containerimages zu erstellen.