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

Artykuł
08/02/2024

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łączonym 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 akcje dla usługi AKS:

Nazwa/nazwisko	opis	Więcej szczegółów
`azure/aks-set-context`	Ustaw docelowy kontekst klastra usługi AKS dla innych akcji, aby użyć lub uruchomić 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 ogólny wpis tajny lub wpis tajny rejestru platformy Docker w klastrze Kubernetes.	azure/k8s-create-secret
`azure/k8s-deploy`	Wdrażanie manifestów w klastrach Kubernetes.	azure/k8s-deploy
`azure/k8s-lint`	Zweryfikuj/lint 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 w module uruchamiającym.	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łasnych agentów dla funkcji 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ć program Open ID Connect (OIDC) i zaktualizować azure/login akcję, aby użyć funkcji OIDC. Aby uzyskać więcej informacji, zobacz Konfigurowanie logowania do platformy Azure przy użyciu uwierzytelniania openID Connect.

Rozwidlenie i aktualizowanie repozytorium

Przejdź do repozytorium Azure Vote i wybierz pozycję Rozwidlenie.
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 repozytorium.

Tworzenie wpisów tajnych

Utwórz jednostkę usługi, aby uzyskać dostęp do grupy zasobów przy Contributor użyciu roli przy użyciu az ad sp create-for-rbac polecenia . Zastąp <SUBSCRIPTION_ID> ciąg identyfikatorem subskrypcji konta platformy Azure i <RESOURCE_GROUP> nazwą grupy zasobów zawierającej usługę 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 pozycję Wpisy tajne zabezpieczeń>i zmienne>Akcje.

Dla każdego wpisu tajnego wybierz pozycję Nowy wpis tajny repozytorium i wprowadź nazwę i wartość wpisu tajnego.

Nazwa wpisu tajnego	Wartość wpisu tajnego
AZURE_CREDENTIALS	Całe dane wyjściowe JSON z `az ad sp create-for-rbac` polecenia .
service_principal	Wartość `<clientId>`.
service_principal_password	Wartość `<clientSecret>`.
subskrypcja	Wartość `<subscriptionId>`.
tenant	Wartość `<tenantId>`.
rejestr	Nazwa rejestru.
repozytorium	azuredocs
resource_group	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 po wypchnięciu zmiany do azure-vote katalogu.

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

Kod źródłowy wyewidencjonowania używa akcji wyewidencjonowania funkcji GitHub Actions w celu sklonowania repozytorium.
Kompilacja usługi ACR używa akcji kompilacji usługi Azure Container Registry do skompilowania obrazu i przekazania go do rejestru.
Logowanie do platformy Azure używa akcji logowania platformy Azure do logowania się do konta platformy Azure.
Ustaw kontekst usługi AKS za pomocą akcji kontekstowej zestawu usługi 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 w usłudze AKS używa akcji wdrażania platformy Azure Kubernetes w celu wdrożenia aplikacji w klastrze Kubernetes.

.github/workflows/main.yml Zatwierdź plik w 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 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

Udostępnij za pośrednictwem