Distribuera din molnbaserade app manuellt till Azure Kubernetes Service

8 minuter

Innan du kan automatisera dina webbplatsdistributioner måste du distribuera den befintliga eShop-appen manuellt till Azure Kubernetes Service (AKS). Du skapar Azure-resurserna och distribuerar appen till AKS med hjälp av Azure CLI-kommandon och bash-skript. Slutligen skapar du ett Azure Active Directory-tjänsthuvudnamn (Azure AD) som gör att GitHub Actions kan distribueras till AKS och Azure Container Registry.

Kommandona skapar följande resurser för att distribuera en uppdaterad version av eShop-appen.

Etablera ett Azure Container Registry (ACR) och skicka sedan avbildningar till registret.
Etablera ett AKS-kluster och distribuera sedan containrarna till klustret.
Testa distributionen.
Skapa tjänstens huvudnamn så att GitHub Actions kan distribueras till AKS och Azure Container Registry.

Viktigt!

Kontrollera att du har slutfört förutsättningarna innan du börjar.

Öppna utvecklingsmiljön

Du kan välja att använda ett GitHub-kodområde som är värd för övningen eller slutföra övningen lokalt i Visual Studio Code.

Konfiguration av GitHub Codespaces

Förgrena lagringsplatsen https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops till ditt eget GitHub-konto. Sedan på din nya förgrening:

Välj Kod.
Välj fliken Codespaces .
+ Välj ikonen för att skapa ditt kodområde.

GitHub tar flera minuter att skapa och konfigurera kodområdet. När processen är klar visas kodfilerna för övningen.

Valfritt: Installation av Visual Studio Code

Om du vill använda Visual Studio Code förgrenar du lagringsplatsen https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops till ditt eget GitHub-konto och klonar den lokalt. Sedan:

Installera alla systemkrav för att köra Dev Container i Visual Studio Code.
Kontrollera att Docker körs.
Öppna mappen för den klonade lagringsplatsen i ett nytt Visual Studio Code-fönster
Tryck på Ctrl+Skift+P för att öppna kommandopaletten.
Sök: >Dev Containers: Återskapa och öppna igen i container
Visual Studio Code skapar din utvecklingscontainer lokalt.

Skapa containrar

Kör det här DOTNET CLI-kommandot i terminalfönstret:
```
dotnet publish /p:PublishProfile=DefaultContainer 
```

Skapa Azure-resurserna

I terminalfönstret loggar du in på Azure med det här Azure CLI-kommandot:
```
az login --use-device-code
```
Visa den valda Azure-prenumerationen.
```
az account show -o table
```
Om fel prenumeration har valts använder du kommandot az account set för att välja rätt.
Kör följande Azure CLI-kommando för att hämta en lista över Azure-regioner och namnet som är associerat med det:
```
az account list-locations -o table
```
Leta upp en region som är närmast dig och använd den i nästa steg genom att ersätta [Closest Azure region]
Kör dessa bash-instruktioner:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
Föregående kommandon skapar miljövariabler som du ska använda i nästa Azure CLI-kommandon. Du måste ändra LOCATION till en Azure-region nära dig, till exempel eastus. Om du vill ha ett annat namn för resursgruppen, AKS-klustret eller ACR ändrar du dessa värden. Om du vill visa dina nya lagringsplatser i Azure-portalen tilldelar du dig själv som Administratör för appefterlevnadsautomatisering i åtkomstkontroll (IAM) i containerregistret.
Kör följande Azure CLI-kommandon:
```
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
```
Om du får ett autentiseringsfel när az acr login --name $ACR_Name den körs måste du aktivera administratörsanvändaren i det nyligen skapade containerregistret i Azure under Inställningar – Åtkomstnycklar. Azure uppmanar dig att ange dessa autentiseringsuppgifter för att fortsätta. Du kan också behöva autentisera igen med az login --use-device-code.

Dessa kommandon skapar en resursgrupp som innehåller Azure-resurserna, en ACR för dina avbildningar och loggar sedan in på ACR. Det kan ta några minuter innan du ser dessa utdata:
```
  ...
  },
  "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
```

Om du vill tagga avbildningarna och push-överföra dem till den ACR som du skapade kör du följande kommandon:

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 kontrollera att push-överföringen av avbildningarna har slutförts med det här kommandot:

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

Skapa din AKS och anslut den till ACR med följande kommandon:

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

Kommandona ovan skapar ett AKS-kluster med en enda nod, ansluter det till ACR och ansluter sedan den lokala datorn till AKS-klustret. Det kan ta några minuter att slutföra kommandona ovan.

Kontrollera att den nya AKS kan hämta avbildningar från ACR med det här kommandot:

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

Du bör se liknande utdata som följande meddelanden:

[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: 71588cd0-9229-4914-9c8e-1dc229d775c8
[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!

Nu kan du köra kubectl-kommandon mot ditt nya AKS-kluster. Kopiera den fullständiga ACR-URL:en från utdata. Ovanför URL:en finns till exempel acseshop1251599299.

Kontrollera statusen för ditt AKS-kluster:

kubectl get nodes -A

Du bör se liknande utdata som följande meddelanden:

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

Konfigurera Kubernetes-distributionsmanifestet

Nu finns eShop-avbildningarna i ACR som du kan uppdatera AKS-distributionsmanifestet för att använda dessa nya avbildningar.

I Visual Studio Code går du till explorer-panelen och väljer deployment.yml filen i projektets rot.

Ersätt på rad 17:

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

Klistra in det kopierade ACR-namnet från föregående steg – raden bör se ut ungefär så här:

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

Upprepa de här stegen för rad 65:

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

Spara filen med CTRL+S.

I terminalfönstret distribuerar du en NGINX-ingresskontrollant med följande kubernetes-kommando:

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

Kommandot ovan kubectl lägger till tjänster och komponenter för att tillåta ingress till ditt AKS-kluster. Kontrollera att ingressen är redo att köras med följande kubernetes-kommando:

kubectl get services --namespace ingress-nginx

Du bör se liknande utdata som följande meddelanden:

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

Distribuera eShop-appen med det här kommandot:
```
kubectl apply -f deployment.yml
```
Kommandot kubectl apply distribuerar eShop-appen, en Blazor-webbapp på klientsidan och rest-API-produkttjänsten för serverdelen och en ingressregel för att dirigera trafik till rätt tjänster till ditt AKS-kluster. Kör det här kommandot igen om du får något fel i distributionerna.

Du bör se liknande utdata som följande meddelanden:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Kontrollera att de två mikrotjänsterna har distribuerats med det här kommandot:

kubectl get pods -A

Du bör se liknande utdata som följande meddelanden:

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

Visa den distribuerade eShop med det här kommandot:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Kommandot ovan returnerar den externa IP-adressen för webbappen. Håll ned CTRL och klicka på länken för att öppna appen på en ny flik.

Skapa ett huvudnamn för tjänsten för distribution från GitHub

GitHub Actions kan publicera containeravbildningar till ett Azure Container Registry. GitHub-löparen måste därför ha behörighet att ansluta till Azure. Följande steg skapar ett Huvudnamn för Azure AD-tjänsten som fungerar som GitHub Actions-identitet i Azure.

Om du vill spara ditt prenumerations-ID i en miljövariabel kör du följande kommando i terminalen:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Kör följande kommando för att skapa ett Huvudnamn för Azure AD-tjänsten för att tillåta åtkomst från GitHub:

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

En variant av följande utdata visas:

Creating 'Contributor' role assignment under scope '/subscriptions/00000000-0000-0000-0000-000000000000'

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": "00000000-0000-0000-0000-000000000000",
  "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/"
}

Kopiera JSON-utdata och hakparenteser som ska användas i nästa steg.

Skapa GitHub-hemligheterna

GitHub Actions-löparen använder autentiseringsuppgifter för att interagera med Container Registry och AKS. Tjänstens huvudnamn och autentiseringsuppgifterna för containerregistret är känslig information. Det är bäst att lagra känslig information som krypterade hemligheter på en säker plats. GitHub tillhandahåller en inbyggd plats för att lagra hemligheter och andra variabler.

Utför följande steg för att lagra känslig information på ett säkert sätt som miljövariabler på lagringsplatsen. Lagringsplatsadministratörer bör hantera hemligheterna som GitHub Actions-löparen kan komma åt.

I din förgrenade GitHub-lagringsplats går du till SettingsActions>Secrets and variables>.
På sidan Actions secrets and variables väljer du New repository secret.
På sidan New secret under Nameanger du AZURE_CREDENTIALS och under Secretanger du JSON-utdata som du kopierade från terminalen.

Inställningarna bör se ut ungefär så här:
Välj Add secret.

Du använder den här GitHub-hemligheten i nästa avsnitt för att skapa en GitHub-åtgärd för att skapa containeravbildningen.

Fortsätt

Distribuera din molnbaserade app manuellt till Azure Kubernetes Service

Öppna utvecklingsmiljön

Konfiguration av GitHub Codespaces

Valfritt: Installation av Visual Studio Code

Skapa containrar

Skapa Azure-resurserna

Konfigurera Kubernetes-distributionsmanifestet

Skapa ett huvudnamn för tjänsten för distribution från GitHub

Skapa GitHub-hemligheterna

Feedback