Ręczne wdrażanie aplikacji natywnej dla chmury w usłudze Azure Kubernetes Service

8 min

Przed zautomatyzowanie wdrożeń witryny internetowej należy ręcznie wdrożyć istniejącą aplikację eShop w usłudze Azure Kubernetes Service (AKS). Tworzysz zasoby Azure i wdrażasz aplikację w usłudze AKS, używając poleceń Azure CLI i skryptów bash. Na koniec utworzysz jednostkę usługi Azure Active Directory (Azure AD), aby umożliwić usłudze GitHub Actions wdrażanie w usługach AKS i Azure Container Registry.

Polecenia tworzą następujące zasoby, aby wdrożyć zaktualizowaną wersję aplikacji eShop.

Aprowizuj usługę Azure Container Registry (ACR), a następnie wypchnij obrazy do rejestru.
Skonfiguruj klaster AKS i wdrażaj kontenery w klastrze.
Przetestuj wdrożenie.
Utwórz zasady dostępu do usługi, aby umożliwić GitHub Actions wdrażanie do AKS i Azure Container Registry.

Ważny

Przed rozpoczęciem upewnij się, że zostały spełnione wymagania wstępne .

Otwieranie środowiska projektowego

Możesz użyć przestrzeni kodu usługi GitHub, która hostuje ćwiczenie, lub wykonać ćwiczenie lokalnie w programie Visual Studio Code.

Konfiguracja usługi GitHub Codespaces

Sforkuj repozytorium https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops na własne konto GitHub. Następnie na Twoim nowym forku:

Wybierz Kod.
Wybierz kartę Codespaces.
Wybierz ikonę +, aby utworzyć przestrzeń kodu.

Utworzenie i skonfigurowanie przestrzeni kodu w usłudze GitHub trwa kilka minut. Po zakończeniu procesu zobaczysz pliki kodu dla ćwiczenia.

Opcjonalnie: Konfiguracja programu Visual Studio Code

Aby użyć programu Visual Studio Code, rozgałęź repozytorium https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops na swoje konto na GitHub i sklonuj je lokalnie. Wtedy:

Zainstaluj wszystkie wymagania systemowe , aby uruchomić kontener deweloperski w programie Visual Studio Code.
Upewnij się, że platforma Docker jest uruchomiona.
W nowym oknie programu Visual Studio Code otwórz folder sklonowanego repozytorium
Naciśnij Ctrl+Shift+P, aby otworzyć paletę poleceń.
Wyszukiwanie: >Dev Containers: przebudowa i ponowne otwarcie w kontenerze
Visual Studio Code tworzy kontener programistyczny lokalnie.

Budowanie kontenerów

W okienku terminalu uruchom następujące polecenie dotnet CLI:
```
dotnet publish /p:PublishProfile=DefaultContainer 
```

Tworzenie zasobów platformy Azure

W okienku terminalu zaloguj się do Azure za pomocą tego polecenia Azure CLI:
```
az login --use-device-code
```
Wyświetl wybraną subskrypcję platformy Azure.
```
az account show -o table
```
Jeśli wybrano niewłaściwą subskrypcję, użyj polecenia az account set, aby wybrać odpowiednią subskrypcję.
Uruchom następujące polecenie Azure CLI, aby uzyskać listę regionów Azure i skojarzoną z nimi nazwą:
```
az account list-locations -o table
```
Znajdź region najbliżej Ciebie i użyj go w następnym kroku, zastępując [Closest Azure region]
Uruchom następujące instrukcje powłoki bash:
```
export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM
```
Poprzednie polecenia tworzą zmienne środowiskowe, które będą używane w następnych poleceniach interfejsu wiersza polecenia platformy Azure. Musisz zmienić LOCATION na region platformy Azure blisko Ciebie; na przykład eastus. Jeśli chcesz zmienić nazwę grupy zasobów, klastra usługi AKS lub usługi ACR, zmień te wartości. Aby wyświetlić nowe repozytoria w portalu Azure, przypisz sobie rolę App Compliance Automation Administrator w Kontroli dostępu (IAM) rejestru kontenerów.
Uruchom następujące polecenia Azure CLI:
```
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
```
Jeśli podczas uruchamiania az acr login --name $ACR_Name zostanie wyświetlony błąd uwierzytelniania, musisz włączyć administratora w nowo utworzonym rejestrze kontenerów na platformie Azure w obszarze Ustawienia — Klucze dostępu. Platforma Azure monituje o wprowadzenie tych poświadczeń, aby kontynuować. Konieczne może być również ponowne uwierzytelnienie przy użyciu az login --use-device-code.

Te polecenia tworzą grupę zasobów, aby zawierała zasoby platformy Azure, usługę ACR dla obrazów, a następnie logowanie do usługi ACR. Może upłynąć kilka minut, zanim zobaczysz następujące dane wyjściowe:
```
  ...
  },
  "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
```

Aby oznaczyć obrazy i wypchnąć je do utworzonego rekordu ACR, uruchom następujące polecenia:

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

Możesz sprawdzić, czy wypychanie obrazów zakończyło się pomyślnie, używając tego polecenia:

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

Utwórz usługę AKS i połącz ją z usługą ACR przy użyciu następujących poleceń:
```
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
```
Powyższe polecenia tworzą klaster usługi AKS z jednym węzłem, łączą go z usługą ACR, a następnie łączą maszynę lokalną z klastrem usługi AKS. Wykonanie powyższych poleceń może potrwać kilka minut.

Sprawdź, czy nowa usługa AKS może ściągać obrazy z usługi ACR za pomocą tego polecenia:

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

Powinieneś zobaczyć podobne wyniki do następujących komunikatów:

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

Teraz można uruchamiać polecenia kubectl na nowym klastrze AKS. Skopiuj pełny adres URL usługi ACR z wyników; na przykład powyżej znajduje się adres URL acseshop1251599299.

Sprawdź stan klastra usługi AKS:

kubectl get nodes -A

Powinny zostać wyświetlone podobne wyniki jak w poniższych komunikatach.

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

Konfigurowanie manifestu wdrożenia platformy Kubernetes

Teraz, gdy obrazy eShop znajdują się w ACR, możesz zaktualizować manifest wdrożenia AKS, aby używać tych nowych obrazów.

W programie Visual Studio Code z panelu EKSPLORATOR wybierz plik deployment.yml w katalogu głównym projektu.
Zastąp element w wierszu 17:
```
- image: [replace with your ACR name].azurecr.io/storeimage:v1
```
Wklej skopiowaną nazwę ACR z poprzedniego kroku — wiersz powinien przypominać następujący kod yaml:
```
- image: acseshop1251599299.azurecr.io/storeimage:v1
```
Powtórz następujące kroki dla wiersza 65:
```
- image: [replace with your ACR name].azurecr.io/productservice:v1
```
Zapisz plik za pomocą CTRL+S.

W terminalu wdróż kontroler Ingress NGINX za pomocą następującego polecenia w Kubernetes:

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

Powyższe polecenie kubectl dodaje składniki i usługi, aby umożliwić wejście do klastra usługi AKS. Sprawdź, czy Ingress jest gotowy do uruchomienia przy użyciu następującego polecenia Kubernetes:

kubectl get services --namespace ingress-nginx

Powinny zostać wyświetlone podobne dane wyjściowe do następujących komunikatów:

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

Wdróż aplikację eShop za pomocą tego polecenia:
```
kubectl apply -f deployment.yml
```
Polecenie kubectl apply wdraża aplikację eShop, aplikację Blazor frontend i usługę produktu interfejsu API REST zaplecza oraz regułę wejściową do kierowania ruchu do odpowiednich usług w klastrze AKS. Uruchom ponownie to polecenie, jeśli wystąpi błąd we wdrożeniach.

Powinny zostać wyświetlone komunikaty podobne do następujących:
```
deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created
```

Sprawdź, czy dwie mikrousługi są wdrażane za pomocą tego polecenia:

kubectl get pods -A

Powinny być widoczne podobne wyniki, jak następujące komunikaty:

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

Wyświetl wdrożony sklep eShop za pomocą tego polecenia:
```
echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Powyższe polecenie zwraca zewnętrzny adres IP aplikacji internetowej. Przytrzymaj ctrl i kliknij link, aby otworzyć aplikację na nowej karcie.

Utwórz pryncypał usługi do wdrażania z GitHub

Funkcja GitHub Actions może publikować obrazy kontenerów w usłudze Azure Container Registry. Dlatego moduł uruchamiający usługę GitHub musi mieć uprawnienia do nawiązywania połączenia z platformą Azure. Poniższe kroki umożliwiają utworzenie jednostki usługi Azure AD, która będzie działać jako tożsamość funkcji GitHub Actions na platformie Azure.

Aby zapisać identyfikator subskrypcji w zmiennej środowiskowej, uruchom następujące polecenie w terminalu:
```
export SUBS=$(az account show --query 'id' --output tsv)
```

Aby utworzyć jednostkę usługi Azure AD w celu zezwolenia na dostęp z usługi GitHub, uruchom następujące polecenie:

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

Zostanie wyświetlona odmiana następujących danych wyjściowych:

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

Skopiuj dane wyjściowe i nawiasy JSON do użycia w następnym kroku.

Utwórz tajemnice GitHub

Moduł GitHub Actions używa poświadczeń do komunikacji z Container Registry i AKS. Główna usługa i poświadczenia rejestru kontenerów są poufnymi informacjami. Najlepiej przechowywać poufne informacje jako zaszyfrowane wpisy tajne w bezpiecznej lokalizacji. Usługa GitHub udostępnia wbudowaną lokalizację do przechowywania wpisów tajnych i innych zmiennych.

Wykonaj poniższe kroki, aby bezpiecznie przechowywać poufne informacje jako zmienne środowiskowe w repozytorium. Administratorzy repozytorium powinni zarządzać sekretami, do których runner GitHub Actions może uzyskiwać dostęp.

W swoim skopiowanym repozytorium GitHub przejdź do Settings>Secrets and variables>Actions.
Na stronie Actions secrets and variables wybierz pozycję New repository secret.
Na stronie New secret w obszarze Namewprowadź AZURE_CREDENTIALS, a w obszarze Secretwprowadź dane wyjściowe JSON skopiowane z terminalu.

Ustawienia powinny wyglądać podobnie jak na poniższym zrzucie ekranu:
Wybierz pozycję Add secret.

W następnej sekcji użyjesz tego sekretu GitHub, aby utworzyć akcję GitHub do zbudowania obrazu kontenera.