Uw cloudeigen app handmatig implementeren in Azure Kubernetes Service

8 minuten

Voordat u uw website-implementaties kunt automatiseren, moet u de bestaande eShop-app handmatig implementeren in Azure Kubernetes Service (AKS). U maakt de Azure-resources en implementeert de app in AKS met behulp van Azure CLI-opdrachten en bash-scripts. Ten slotte maakt u een service-principal voor Azure Active Directory (Azure AD) om GitHub Actions toe te staan om te implementeren in AKS en Azure Container Registry.

Met de opdrachten worden de volgende resources gemaakt om een bijgewerkte versie van de eShop-app te implementeren.

Richt een Azure Container Registry (ACR) in en push vervolgens afbeeldingen naar het containerregister.
Richt een AKS-cluster in en implementeer vervolgens de containers in het cluster.
Test de implementatie.
Maak service-principals zodat GitHub Actions kan worden geïmplementeerd in AKS en Azure Container Registry.

Belangrijk

Zorg ervoor dat u de vereisten hebt voltooid voordat u begint.

De ontwikkelomgeving openen

U kunt ervoor kiezen om een GitHub-coderuimte te gebruiken die als host fungeert voor de oefening of om de oefening lokaal te voltooien in Visual Studio Code.

Installatie van GitHub Codespaces

Fork de https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repository naar je eigen GitHub-account. Vervolgens op je nieuwe fork:

Selecteer Code.
Selecteer het tabblad Codespaces.
Selecteer het pictogram + om uw coderuimte te maken.

GitHub duurt enkele minuten om de codespace te maken en te configureren. Wanneer het proces is voltooid, ziet u de codebestanden voor de oefening.

Optioneel: Installatie van Visual Studio Code

Als je Visual Studio Codewilt gebruiken, fork dan de https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops repository naar je eigen GitHub-account en kloon deze lokaal. Dan:

Installeer eventuele systeemeisen om Dev Container in Visual Studio Code uit te voeren.
Zorg ervoor dat Docker wordt uitgevoerd.
Open in een nieuw Visual Studio Code-venster de map van de gekloonde opslagplaats
Druk op Ctrl+Shift+P om het opdrachtenpalet te openen.
Zoeken: >Dev-containers: herbouwen en opnieuw openen in container
Visual Studio Code maakt uw ontwikkelcontainer lokaal.

Containers bouwen

Voer in het terminalvenster deze dotnet CLI-opdracht uit:
```
dotnet publish /p:PublishProfile=DefaultContainer 
```

De Azure-resources maken

Meld u in het terminalvenster aan bij Azure met deze Azure CLI-opdracht:
```
az login --use-device-code
```
Bekijk het geselecteerde Azure-abonnement.
```
az account show -o table
```
Als het verkeerde abonnement is geselecteerd, gebruikt u de opdracht az account set om de juiste te selecteren.
Voer de volgende Azure CLI-opdracht uit om een lijst met Azure-regio's en de bijbehorende naam op te halen:
```
az account list-locations -o table
```
Zoek een regio die het dichtst bij u in de buurt is en gebruik deze in de volgende stap door [Closest Azure region] te vervangen.
Voer deze bash-instructies uit:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
Met de vorige opdrachten maakt u omgevingsvariabelen die u in de volgende Azure CLI-opdrachten gaat gebruiken. Je moet de LOCATION- wijzigen in een Azure-regio dicht bij jou in de buurt; bijvoorbeeld eastus. Als u een andere naam wilt voor uw resourcegroep, AKS-cluster of ACR, wijzigt u deze waarden. Als u uw nieuwe repositories in de Azure-portal wilt weergeven, ken uzelf de rol toe van App Compliance Automation-beheerder in het Toegangsbeheer (IAM) van het containerregister.
Voer deze Azure CLI-opdrachten uit:
```
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
```
Als er een verificatiefout optreedt wanneer az acr login --name $ACR_Name wordt uitgevoerd, moet u gebruiker met beheerdersrechten inschakelen in het zojuist gemaakte containerregister in Azure onder Instellingen - Toegangssleutels. Azure vraagt u om deze referenties in te voeren om door te gaan. U kunt ook opnieuw verifiëren met az login --use-device-code.

Met deze opdrachten maakt u een resourcegroep aan om de Azure-resources te bevatten, maakt u een ACR voor uw containerafbeeldingen, en meldt u zich vervolgens aan bij de ACR. Het kan enkele minuten duren voordat u deze uitvoer ziet:
```
  ...
  },
  "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
```

Voer de volgende commando's uit om uw afbeeldingen te taggen en naar de gemaakte ACR te pushen:

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

U kunt verifiëren of het uploaden van de afbeeldingen is voltooid met deze opdracht:

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

Maak uw AKS en verbind deze met de ACR met deze opdrachten:
```
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
```
Met de bovenstaande opdrachten maakt u een AKS-cluster met één knooppunt, verbindt u het met de ACR en verbindt u vervolgens uw lokale computer met het AKS-cluster. Het kan enkele minuten duren voordat de bovenstaande opdrachten zijn voltooid.

Controleer met het volgende commando of de AKS afbeeldingen uit de ACR kan ophalen:

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

U zou vergelijkbare uitvoer moeten zien als de volgende berichten:

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

U kunt nu kubectl-opdrachten uitvoeren op uw nieuwe AKS-cluster. Kopieer de volledige ACR-URL uit de uitvoer; Boven de URL is bijvoorbeeld acseshop1251599299.

Controleer de status van uw AKS-cluster:

kubectl get nodes -A

U zou een vergelijkbare uitvoer moeten zien als in de volgende berichten:

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

Het Kubernetes-implementatiemanifest configureren

Nu bevinden de eShop-installatiekopieën zich in de ACR, kunt u het AKS-implementatiemanifest bijwerken om deze nieuwe installatiekopieën te gebruiken.

Selecteer in Visual Studio Code in het deelvenster EXPLORER het bestand deployment.yml in de basisdirectory van het project.

Vervangen op regel 17:

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

Plak de gekopieerde ACR-naam uit de vorige stap: de regel moet er ongeveer als volgt uitzien:

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

Herhaal deze stappen voor regel 65:

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

Sla het bestand op met Ctrl+S-.

Implementeer in het terminalvenster een NGINX-ingangscontroller met de volgende kubernetes-opdracht:

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

Met de bovenstaande kubectl opdracht worden services en onderdelen toegevoegd om inkomend verkeer in uw AKS-cluster toe te staan. Controleer of de ingress gereed is met behulp van de volgende kubernetes opdracht:

kubectl get services --namespace ingress-nginx

U zou uitvoer moeten zien die vergelijkbaar is met de volgende berichten:

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

Implementeer de eShop-app met deze opdracht:
```
kubectl apply -f deployment.yml
```
De kubectl-opdracht implementeert de eShop-app: een front-end Blazor web-app en een back-end REST API-productservice, en een regel voor inkomend verkeer om het verkeer naar de juiste services in uw AKS-cluster te routeren. Voer deze opdracht opnieuw uit als er een fout optreedt bij implementaties.

U zou vergelijkbare uitvoer als de volgende berichten moeten zien:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Controleer of de twee microservices zijn geïmplementeerd met deze opdracht:

kubectl get pods -A

U zou een vergelijkbare uitvoer moeten zien als de volgende berichten:

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

Bekijk de geïmplementeerde eShop met deze opdracht:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Met de bovenstaande opdracht wordt het externe IP-adres voor de web-app geretourneerd. Houd Ctrl- ingedrukt en klik op de koppeling om de app op een nieuw tabblad te openen.

Een service-principal maken voor implementatie vanuit GitHub

GitHub Actions kan containerinstallatiekopieën publiceren naar een Azure Container Registry. De GitHub-runner moet daarom machtigingen hebben om verbinding te maken met Azure. Met de volgende stappen maakt u een Azure AD-service-principal om te fungeren als de GitHub Actions-identiteit in Azure.

Voer de volgende opdracht uit in de terminal om uw abonnements-id op te slaan in een omgevingsvariabele:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Voer de volgende opdracht uit om een Azure AD-service-principal te maken om toegang vanuit GitHub toe te staan:

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

Er wordt een variant van de volgende uitvoer weergegeven:

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

Kopieer de JSON-uitvoer en de vierkante haken om in de volgende stap te gebruiken.

De GitHub-geheimen maken

De GitHub Actions-runner gebruikt referenties om te communiceren met Container Registry en AKS. De service-principal en de inloggegevens voor het containerregister zijn gevoelige informatie. Het is raadzaam om gevoelige informatie op te slaan als versleutelde geheimen op een veilige locatie. GitHub biedt een ingebouwde locatie voor het opslaan van geheimen en andere variabelen.

Voer de volgende stappen uit om gevoelige informatie veilig op te slaan als omgevingsvariabelen in uw opslagplaats. Beheerders van opslagplaatsen moeten de geheimen beheren waartoe de GitHub Actions-runner toegang heeft.

Ga in uw gesplitste GitHub-opslagplaats naar Settings>Secrets and variables>Actions.
Selecteer New repository secretop de pagina Actions secrets and variables.
Voer op de pagina New secret, onder Name, AZURE_CREDENTIALSin en voer onder Secretde JSON-uitvoer in die u uit de terminal hebt gekopieerd.

De instellingen moeten er ongeveer uitzien als in de volgende schermopname:
Selecteer Add secret.

Gebruik dit GitHub-geheim in het volgende gedeelte om een GitHub-actie aan te maken om de containerimage te bouwen.