Kompilowanie, testowanie i wdrażanie kontenerów w usłudze Azure Kubernetes Service (AKS) przy użyciu funkcji GitHub Actions

Funkcja GitHub Actions zapewnia elastyczność tworzenia zautomatyzowanego przepływu pracy cyklu tworzenia oprogramowania. Aby wdrożyć kontenery z usługi Azure Container Registry (ACR) w usłudze Azure Kubernetes Service (AKS) za pomocą funkcji GitHub Actions, można użyć wielu akcji platformy Kubernetes.

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją. Jeśli go nie masz, utwórz bezpłatne konto.
Konto usługi GitHub. Jeśli nie masz takiego konta, zarejestruj się bezpłatnie.
- W przypadku korzystania z funkcji GitHub Actions należy skonfigurować integrację między platformą Azure i repozytorium GitHub. Aby skonfigurować integrację, zobacz Nawiązywanie połączenia z platformą Azure przy użyciu funkcji GitHub Actions.
Istniejący klaster usługi AKS z dołączoną usługą ACR. Jeśli go nie masz, zobacz Uwierzytelnianie za pomocą usługi ACR z usługi AKS.

Funkcja GitHub Actions dla usługi AKS

Za pomocą funkcji GiHub Actions można zautomatyzować przepływy pracy tworzenia oprogramowania z poziomu usługi GitHub. Aby uzyskać więcej informacji, zobacz GitHub Actions for Azure (Funkcja GitHub Actions dla platformy Azure).

W poniższej tabeli wymieniono dostępne działania dla usługi AKS.

Nazwa/nazwisko	opis	Więcej szczegółów
`azure/aks-set-context`	Ustaw docelowy kontekst klastra AKS, aby korzystać z innych akcji lub uruchamiać dowolne polecenia kubectl.	azure/aks-set-context
`azure/k8s-set-context`	Ustaw docelowy kontekst klastra Kubernetes dla innych akcji, aby używać lub uruchamiać dowolne polecenia kubectl.	azure/k8s-set-context
`azure/k8s-bake`	Plik manifestu bake do użycia na potrzeby wdrożeń przy użyciu narzędzia Helm, kustomize lub kompose.	azure/k8s-bake
`azure/k8s-create-secret`	Utwórz sekret ogólny lub sekret rejestru Docker w klastrze Kubernetes.	azure/k8s-create-secret
`azure/k8s-deploy`	Wdrażanie manifestów w klastrach Kubernetes.	azure/k8s-deploy
`azure/k8s-lint`	Sprawdź lub lintuj pliki manifestu.	azure/k8s-lint
`azure/setup-helm`	Zainstaluj określoną wersję pliku binarnego programu Helm w module uruchamiającym.	azure/setup-helm
`azure/setup-kubectl`	Zainstaluj określoną wersję narzędzia kubectl na runnerze.	azure/setup-kubectl
`azure/k8s-artifact-substitute`	Zaktualizuj tag lub skrót dla obrazów kontenerów.	azure/k8s-artifact-substitute
`azure/aks-create-action`	Utwórz klaster usługi AKS przy użyciu narzędzia Terraform.	azure/aks-create-action
`azure/aks-github-runner`	Skonfiguruj własne agenty dla usługi GitHub Actions.	azure/aks-github-runner
`azure/acr-build`	Kompilowanie kontenerów przy użyciu usługi ACR.	azure/acr-build

Używanie funkcji GitHub Actions z usługą AKS

Na przykład możesz użyć funkcji GitHub Actions, aby wdrożyć aplikację w klastrze usługi AKS za każdym razem, gdy zmiana zostanie wypchnięta do repozytorium GitHub. W tym przykładzie użyto aplikacji Azure Vote .

Uwaga

W tym przykładzie użyto jednostki usługi do uwierzytelniania w klastrze ACR i AKS. Alternatywnie można skonfigurować Open ID Connect (OIDC) i zaktualizować działanie azure/login, aby użyć OIDC. Aby uzyskać więcej informacji, zobacz Konfigurowanie logowania do platformy Azure przy użyciu uwierzytelniania openID Connect.

Fork i aktualizacja repozytorium

Przejdź do repozytorium Azure Vote i wybierz pozycję Fork.
Zaktualizuj element azure-vote-all-in-one-redis.yaml , aby użyć usługi ACR dla azure-vote-front obrazu. Zastąp ciąg <registryName> nazwą rejestru.
```
...
      containers:
      - name: azure-vote-front
        image: <registryName>.azurecr.io/azuredocs/azure-vote-front:v1
...
```
Zatwierdź zaktualizowane azure-vote-all-in-one-redis.yaml w repozytorium.

Tworzenie sekretów

Utwórz jednostkę usługi, aby uzyskać dostęp do grupy zasobów z rolą Contributor przy użyciu polecenia az ad sp create-for-rbac. Zastąp <SUBSCRIPTION_ID> identyfikatorem subskrypcji swojego konta Azure i <RESOURCE_GROUP> nazwą grupy zasobów zawierającej ACR.
```
az ad sp create-for-rbac \
    --name "ghActionAzureVote" \
    --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP> \
    --role Contributor \
    --json-auth
```
Dane wyjściowe powinny wyglądać podobnie do następujących przykładowych danych wyjściowych:
```
{
  "clientId": <clientId>,
  "clientSecret": <clientSecret>,
  "subscriptionId": <subscriptionId>,
  "tenantId": <tenantId>,
  ...
}
```
Przejdź do ustawień repozytorium GitHub i wybierz Zabezpieczenia>Tajne dane i zmienne>Akcje.

Dla każdego sekretu wybierz Nowy sekret repozytorium i wprowadź jego nazwę oraz wartość.

Tajna nazwa	Wartość tajna
AZURE_CREDENTIALS	Całe dane JSON wyjściowe z `az ad sp create-for-rbac` polecenia.
service_principal	Wartość `<clientId>`.
service_principal_password	Wartość `<clientSecret>`.
abonament	Wartość `<subscriptionId>`.
dzierżawa	Wartość `<tenantId>`.
rejestr	Nazwa rejestru.
repozytorium	azuredocs
grupa zasobów	Nazwa grupy zasobów.
cluster_name	Nazwa klastra.

Aby uzyskać więcej informacji na temat tworzenia wpisów tajnych, zobacz Zaszyfrowane wpisy tajne.

Tworzenie pliku akcji

W repozytorium utwórz plik .github/workflows/main.yml i wklej następującą zawartość:

name: build_deploy_aks
on:
  push:
    paths:
      - "azure-vote/**"
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout source code 
        uses: actions/checkout@v3
      - name: ACR build
        id: build-push-acr
        uses: azure/acr-build@v1
        with:
          service_principal: ${{ secrets.service_principal }}
          service_principal_password: ${{ secrets.service_principal_password }}
          tenant: ${{ secrets.tenant }}
          registry: ${{ secrets.registry }}
          repository: ${{ secrets.repository }}
          image:  azure-vote-front
          folder: azure-vote
          branch: master
          tag: ${{ github.sha }}
      - name: Azure login
        id: login
        uses: azure/login@v1.4.3
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}
      - name: Set AKS context
        id: set-context
        uses: azure/aks-set-context@v3
        with:
          resource-group: '${{ secrets.resource_group }}' 
          cluster-name: '${{ secrets.cluster_name }}'
      - name: Setup kubectl
        id: install-kubectl
        uses: azure/setup-kubectl@v3
      - name: Deploy to AKS
        id: deploy-aks
        uses: Azure/k8s-deploy@v4
        with:
          namespace: 'default'
          manifests: |
             azure-vote-all-in-one-redis.yaml
          images: '${{ secrets.registry }}.azurecr.io/${{ secrets.repository }}/azure-vote-front:${{ github.sha }}'
          pull-images: false

Sekcja on zawiera zdarzenie, które wyzwala akcję. W przykładowym pliku, akcja jest wyzwalana, gdy zmiana zostanie przekazana do katalogu azure-vote.

Sekcja steps zawiera każdą odrębną akcję:

Polecenie Checkout używa akcji Checkout GitHub Actions do sklonowania repozytorium.
Kompilator ACR używa akcji kompilacji Azure Container Registry do zbudowania obrazu i przesłania go do rejestru.
Azure login korzysta z Azure Login Action aby zalogować się do swojego konta Azure.
Ustaw kontekst usługi AKS za pomocą Akcji Ustawiania Kontekstu Azure AKS, aby ustawić kontekst dla klastra usługi AKS.
Instalator kubectl używa akcji Kubectl Setup Kubectl w usłudze Azure AKS w celu zainstalowania narzędzia kubectl w module uruchamiającym.
Wdrażanie do usługi AKS używa Azure Kubernetes Deploy Action do wdrożenia aplikacji w klastrze Kubernetes.

Zatwierdź plik .github/workflows/main.yml w twoim repozytorium.
Aby potwierdzić, że akcja działa, zaktualizuj element azure-vote/azure-vote/config_file.cfg o następującej zawartości:
```
# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Fish'
VOTE2VALUE = 'Dogs'
SHOWHOST = 'false'
```
Zatwierdź zaktualizowane azure-vote/azure-vote/config_file.cfg w repozytorium.
W repozytorium wybierz pozycję Akcje i upewnij się, że przepływ pracy jest uruchomiony. Następnie upewnij się, że przepływ pracy ma zielony znacznik wyboru, a zaktualizowana aplikacja zostanie wdrożona w klastrze.

Następne kroki

Zapoznaj się z następującymi początkowymi przepływami pracy dla usługi AKS. Aby uzyskać więcej informacji, zobacz Używanie początkowych przepływów pracy.

Dowiedz się, jak utworzyć wiele potoków w funkcji GitHub Actions za pomocą usługi AKS

Dowiedz się więcej o usłudze Azure Kubernetes Service

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-04-03