Distribuer den skybaserte appen manuelt til Azure Kubernetes Service

8 minutter

Før du kan automatisere nettstedsdistribusjonene, må du distribuere den eksisterende eShop-appen manuelt til Azure Kubernetes Service (AKS). Du oppretter Azure-ressursene og distribuerer appen til AKS ved hjelp av Azure CLI-kommandoer og bash-skript. Til slutt oppretter du en azure Active Directory -tjenestekontohaver (Azure AD) for å tillate GitHub-handlinger å distribuere til AKS og Azure Container Registry.

Kommandoene oppretter følgende ressurser for å distribuere en oppdatert versjon av eShop-appen.

Klargjør et Azure Container Registry (ACR) og send deretter bilder til registeret.
Klargjør en AKS-klynge, og distribuer deretter beholderne i klyngen.
Test distribusjonen.
Opprett tjenestekontohavere for å tillate gitHub-handlinger å distribuere til AKS og Azure Container Registry.

Important

Kontroller at du har fullført forutsetningene før du begynner.

Åpne utviklingsmiljøet

Du kan velge å bruke et GitHub-kodeområde som er vert for øvelsen, eller fullføre øvelsen lokalt i Visual Studio Code.

Konfigurasjon av GitHub-kodeområder

Forgren https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repositoriet til din egen GitHub-konto. Deretter på den nye gaffelen:

Velg Kode.
Velg kategorien Kodeområder .
Velg ikonet + for å opprette kodeområdet.

GitHub bruker flere minutter på å opprette og konfigurere kodeområdet. Når prosessen er fullført, ser du kodefilene for øvelsen.

Valgfritt: Konfigurasjon av Visual Studio-kode

Hvis du vil bruke Visual Studio Code, kan du dele https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repositoriet til din egen GitHub-konto og klone den lokalt. Then:

Installer eventuelle systemkrav for å kjøre Dev Container i Visual Studio Code.
Sørg for at Docker kjører.
Åpne mappen til det klonede repositoriet i et nytt Visual Studio Code-vindu
Trykk Ctrl+Shift+P for å åpne kommandopaletten.
Søk: >utviklerbeholdere: Gjenoppbygge og åpne på nytt i beholder
Visual Studio Code oppretter utviklingsbeholderen lokalt.

Bygg beholdere

Kjør denne dotnet CLI-kommandoen i terminalruten:

dotnet publish /p:PublishProfile=DefaultContainer

Opprett Azure-ressursene

Logg på Azure med denne Azure CLI-kommandoen i terminalruten:
```
az login --use-device-code
```
Vis det valgte Azure-abonnementet.
```
az account show -o table
```
Hvis feil abonnement er valgt, bruker du az-kontosettet kommando for å velge riktig.
Kjør følgende Azure CLI-kommando for å få en liste over Azure-områder og navnet som er knyttet til den:
```
az account list-locations -o table
```
Finn et område nærmest deg, og bruk det i neste trinn ved å erstatte [Closest Azure region]
Kjør disse bash-uttalelsene:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
De forrige kommandoene oppretter miljøvariabler som du vil bruke i de neste Azure CLI-kommandoene. Du må endre LOCATION til et Azure-område nær deg, for eksempel eastus. Hvis du vil ha et annet navn for ressursgruppen, AKS-klyngen eller ACR, endrer du disse verdiene. Hvis du vil vise de nye repositoriene i Azure-portalen, tilordner du deg selv som administrator for appsamsvarsautomatisering i Access-kontroll (IAM) av beholderregisteret.

Kjør disse Azure CLI-kommandoene:

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

Hvis du får en godkjenningsfeil når az acr login --name $ACR_Name den kjøres, må du aktivere administratorbruker i det nylig opprettede beholderregisteret i Azure under Innstillinger – Tilgangsnøkler. Azure ber deg angi denne legitimasjonen for å fortsette. Du må kanskje også godkjenne på nytt med az login --use-device-code.

Disse kommandoene oppretter en ressursgruppe som inneholder Azure-ressursene, en acr for bildene dine, og logger deretter på acr. Det kan ta noen minutter før du ser utdataene:

  ...
  },
  "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

Hvis du vil merke bildene og sende dem til ACR-en du opprettet, kjører du disse kommandoene:

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

Du kan kontrollere hvordan du skyver bildene fullstendig med denne kommandoen:

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

Opprett AKS-en og koble den til acr med disse kommandoene:

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

Kommandoene oppretter én enkelt node-AKS-klynge, kobler den til ACR og kobler deretter den lokale maskinen til AKS-klyngen. Kommandoene kan ta noen minutter å fullføre.

Kontroller at den nye AKS-en kan hente bilder fra acr med denne kommandoen:

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

Du bør se lignende utdata som følgende meldinger:

[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!

Du kan nå kjøre kubectl-kommandoer mot den nye AKS-klyngen. Kopier hele ACR-URL-adressen fra utdataene. Over URL-adressen er for eksempel acseshop1251599299.

Kontroller statusen for AKS-klyngen:

kubectl get nodes -A

Du bør se lignende utdata som følgende meldinger:

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

Konfigurer kubernetes-distribusjonsmanifestet

Nå er eShop-bildene i ACR-en du kan oppdatere AKS-distribusjonsmanifestet for å bruke disse nye bildene.

I Visual Studio Code eller Codespaces velger du den deployment.yml filen i roten av prosjektet fra EXPLORER-panelet .

Erstatt på linje 17:

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

Lim inn det kopierte ACR-navnet fra forrige trinn – linjen skal se lik følgende yaml:

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

Gjenta disse trinnene for linje 65:

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

Lagre filen med CTRL+S.

I terminalruten distribuerer du en NGINX-inntrengningskontroller med følgende kubernetes-kommando:

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

Kommandoen kubectl legger til tjenester og komponenter for å tillate inntrengning i AKS-klyngen. Kontroller at inntrengning er klar til å kjøre ved hjelp av følgende kubernetes-kommando:

kubectl get services --namespace ingress-nginx

Du bør se lignende utdata som følgende meldinger:

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

Distribuer eShop-appen med denne kommandoen:
```
kubectl apply -f deployment.yml
```
Den kubectl bruke kommandoen distribuerer eShop-appen, en front-end Blazor web app og back-end REST API produkttjeneste, og en inntrengningsregel for å rute trafikk til de riktige tjenestene til AKS-klyngen. Kjør denne kommandoen på nytt hvis du får en feilmelding om distribusjoner.

Du bør se lignende utdata som følgende meldinger:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Kontroller at de to mikrotjenestene er distribuert med denne kommandoen:

kubectl get pods -A

Du bør se lignende utdata som følgende meldinger:

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

Vis den distribuerte eShop med denne kommandoen:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Kommandoen returnerer den eksterne IP-adressen for nettappen. Hold CTRL og klikk på lenken for å åpne appen i en ny fane.

Opprett en tjenestekontohaver for distribusjon fra GitHub

GitHub-handlinger kan publisere beholderbilder til et Azure Container Registry. GitHub-løperen må derfor ha tillatelse til å koble til Azure. Følgende trinn oppretter en Azure AD-tjenestekontohaver for å fungere som GitHub Actions-identitet i Azure.

Hvis du vil lagre abonnements-ID-en i en miljøvariabel, kjører du følgende kommando i terminalen:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Hvis du vil opprette en Azure AD-tjenestekontohaver for å tillate tilgang fra GitHub, kjører du følgende kommando:

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

En variasjon av følgende utdata vises:

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/"
}

Kopier JSON-utdataene og hakeparentesene som skal brukes i neste trinn.

Opprette GitHub-hemmeligheter

GitHub Actions-løperen bruker legitimasjon til å samhandle med Container Registry og AKS. Tjenestekontohaveren og legitimasjonen for beholderregisteret er sensitiv informasjon. Det er best å lagre sensitiv informasjon som krypterte hemmeligheter på et sikkert sted. GitHub har en innebygd plassering for lagring av hemmeligheter og andre variabler.

Fullfør følgende trinn for å lagre den sensitive informasjonen som miljøvariabler i repositoriet på en sikker måte. Repositoriumadministratorer bør administrere hemmelighetene som GitHub Actions-løperen har tilgang til.

Gå til Settings>Secrets and variables>Actionsi det forgrenede GitHub-repositoriet.
Velg Actions secrets and variablespå New repository secret-siden.
På New secret siden, under Name, skriv inn AZURE_CREDENTIALS, og under Secret, skriv inn JSON-utdataene du kopierte fra terminalen.

Innstillingene skal se omtrent slik ut:
Velg Add secret.

Du bruker denne GitHub-hemmeligheten i neste del til å opprette en GitHub-handling for å bygge beholderbildet.

Tilbakemeldinger

Var denne siden nyttig?