Distribuera en anpassad container till App Service med GitHub Actions

Artikel
07/03/2024

GitHub Actions ger dig flexibiliteten att skapa ett automatiserat arbetsflöde för programvaruutveckling. Med åtgärden Azure Web Deploy kan du automatisera arbetsflödet för att distribuera anpassade containrar till App Service med GitHub Actions.

Ett arbetsflöde definieras av en YAML-fil (.yml) i /.github/workflows/ sökvägen på lagringsplatsen. Den här definitionen innehåller de olika steg och parametrar som finns i arbetsflödet.

För ett Azure App Service-containerarbetsflöde har filen tre avsnitt:

Avsnitt	Uppgifter
Autentisering	1. Hämta tjänstens huvudnamn eller publicera profil. 2. Skapa en GitHub-hemlighet.
Bygge	1. Skapa miljön. 2. Skapa containeravbildningen.
Distribuera	1. Distribuera containeravbildningen.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt
Ett GitHub-konto. Om du inte har ett sådant kan du registrera dig utan kostnad. Du måste ha kod på en GitHub-lagringsplats för att distribuera till Azure App Service.
Ett fungerande containerregister och En Azure App Service-app för containrar. I det här exemplet används Azure Container Registry. Se till att slutföra den fullständiga distributionen till Azure App Service för containrar. Till skillnad från vanliga webbappar har webbappar för containrar inte någon standardlandningssida. Publicera containern för att ha ett fungerande exempel.
- Lär dig hur du skapar ett containerbaserat Node.js-program med Docker, push-överför containeravbildningen till ett register och distribuerar sedan avbildningen till Azure App Service

Generera autentiseringsuppgifter för distribution

Det rekommenderade sättet att autentisera med Azure App Services för GitHub Actions är med en publiceringsprofil. Du kan också autentisera med tjänstens huvudnamn eller Öppna ID Connect, men processen kräver fler steg.

Spara publiceringsprofilens autentiseringsuppgifter eller tjänstens huvudnamn som en GitHub-hemlighet för att autentisera med Azure. Du kommer åt hemligheten i arbetsflödet.

En publiceringsprofil är en autentiseringsuppgift på appnivå. Konfigurera din publiceringsprofil som en GitHub-hemlighet.

Gå till din apptjänst i Azure-portalen.
På sidan Översikt väljer du Hämta publiceringsprofil.

Kommentar

Från och med oktober 2020 behöver Linux-webbappar appinställningen WEBSITE_WEBDEPLOY_USE_SCM inställd true på innan filen laddas ned. Det här kravet tas bort i framtiden. Se Konfigurera en App Service-app i Azure-portalen för att lära dig hur du konfigurerar vanliga inställningar för webbappar.
Spara den nedladdade filen. Du använder innehållet i filen för att skapa en GitHub-hemlighet.

Du kan skapa ett huvudnamn för tjänsten med kommandot az ad sp create-for-rbac i Azure CLI. Kör det här kommandot med Azure Cloud Shell i Azure-portalen eller genom att välja knappen Prova .

az ad sp create-for-rbac --name "myApp" --role contributor \
                            --scopes /subscriptions/<subscription-id>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name> \
                            --json-auth

I exemplet ersätter du platshållarna med ditt prenumerations-ID, resursgruppsnamn och appnamn. Utdata är ett JSON-objekt med autentiseringsuppgifterna för rolltilldelning som ger åtkomst till din App Service-app. Kopiera det här JSON-objektet för senare.

  {
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    (...)
  }

Viktigt!

Det är alltid en bra idé att bevilja minsta möjliga åtkomst. Omfånget i föregående exempel är begränsat till den specifika App Service-appen och inte hela resursgruppen.

OpenID Connect är en autentiseringsmetod som använder kortlivade token. Att konfigurera OpenID Connect med GitHub Actions är en mer komplex process som ger förstärkt säkerhet.

Om du inte har ett befintligt program registrerar du ett nytt Active Directory-program och tjänstens huvudnamn som kan komma åt resurser. Skapa Active Directory-programmet.
```
az ad app create --display-name myApp
```
Det här kommandot matar ut JSON med en appId som är din client-id. Spara värdet som ska användas som AZURE_CLIENT_ID GitHub-hemlighet senare.

Du använder värdet objectId när du skapar federerade autentiseringsuppgifter med Graph API och refererar till det som APPLICATION-OBJECT-ID.
Skapa ett huvudnamn för tjänsten. $appID Ersätt med appId från dina JSON-utdata.

Det här kommandot genererar JSON-utdata med en annan objectId och används i nästa steg. Den nya objectId är assignee-object-id.

Kopiera som appOwnerTenantId ska användas som en GitHub-hemlighet för AZURE_TENANT_ID senare.
```
 az ad sp create --id $appId
```
Skapa en ny rolltilldelning efter prenumeration och objekt. Som standard är rolltilldelningen kopplad till din standardprenumeration. Ersätt $subscriptionId med ditt prenumerations-ID, $resourceGroupName med resursgruppens namn och $assigneeObjectId med det genererade assignee-object-id. Lär dig hur du hanterar Azure-prenumerationer med Azure CLI.
```
az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --assignee-principal-type ServicePrincipal --scopes /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/
```
Kör följande kommando för att skapa en ny federerad identitetsautentiseringsuppgift för ditt Active Directory-program.
- Ersätt APPLICATION-OBJECT-ID med objectId (genereras när du skapar appen) för ditt Active Directory-program.
- Ange ett värde som CREDENTIAL-NAME ska refereras senare.
- subjectAnge . Värdet för detta definieras av GitHub beroende på ditt arbetsflöde:
  - Jobb i din GitHub Actions-miljö: repo:< Organization/Repository >:environment:< Name >
  - För Jobb som inte är knutna till en miljö inkluderar du referenssökvägen för gren/tagg baserat på referenssökvägen som används för att utlösa arbetsflödet: repo:< Organization/Repository >:ref:< ref path>. Exempel: repo:n-username/ node_express:ref:refs/heads/my-branch eller repo:n-username/ node_express:ref:refs/tags/my-tag.
  - För arbetsflöden som utlöses av en pull-begärandehändelse: repo:< Organization/Repository >:pull_request.
```
az rest --method POST --uri 'https://graph.microsoft.com/beta/applications/<APPLICATION-OBJECT-ID>/federatedIdentityCredentials' --body '{"name":"<CREDENTIAL-NAME>","issuer":"https://token.actions.githubusercontent.com","subject":"repo:organization/repository:ref:refs/heads/main","description":"Testing","audiences":["api://AzureADTokenExchange"]}' 
```
Information om hur du skapar ett Skapa ett active directory-program, tjänstens huvudnamn och federerade autentiseringsuppgifter i Azure-portalen finns i Ansluta GitHub och Azure.

Konfigurera GitHub-hemligheten för autentisering

I GitHub bläddrar du till lagringsplatsen. Välj Inställningar Säkerhetshemligheter > > och variabler > Åtgärder > Ny lagringsplatshemlighet.

Om du vill använda autentiseringsuppgifter på appnivå klistrar du in innehållet i den nedladdade publiceringsprofilfilen i hemlighetens värdefält. Ge hemligheten AZURE_WEBAPP_PUBLISH_PROFILEnamnet .

När du konfigurerar ditt GitHub-arbetsflöde använder AZURE_WEBAPP_PUBLISH_PROFILE du i åtgärden distribuera Azure Web App. Till exempel:

- uses: azure/webapps-deploy@v2
  with:
    publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}

I GitHub bläddrar du till lagringsplatsen. Välj Inställningar Säkerhetshemligheter > > och variabler > Åtgärder > Ny lagringsplatshemlighet.

Om du vill använda autentiseringsuppgifter på användarnivå klistrar du in hela JSON-utdata från Azure CLI-kommandot i hemlighetens värdefält. Ge hemligheten ett namn, till exempel AZURE_CREDENTIALS.

När du konfigurerar arbetsflödesfilen senare använder du hemligheten för indata creds från Azure Login-åtgärden. Till exempel:

- uses: azure/login@v1
  with:
    creds: ${{ secrets.AZURE_CREDENTIALS }}

Du måste ange programmets klient-ID, klient-ID och prenumerations-ID till inloggningsåtgärden. Dessa värden kan antingen anges direkt i arbetsflödet eller lagras i GitHub-hemligheter och refereras till i arbetsflödet. Att spara värdena som GitHub-hemligheter är det säkrare alternativet.

Öppna din GitHub-lagringsplats och gå till Inställningar > Säkerhetshemligheter > och variabler > Åtgärder > Ny lagringsplatshemlighet.
Skapa hemligheter för AZURE_CLIENT_ID, AZURE_TENANT_IDoch AZURE_SUBSCRIPTION_ID. Använd dessa värden från ditt Active Directory-program för dina GitHub-hemligheter. Du hittar dessa värden i Azure-portalen genom att söka efter ditt Active Directory-program.

GitHub-hemlighet Active Directory-program

AZURE_CLIENT_ID App-ID (klient-ID)

AZURE_TENANT_ID Katalog-ID (klientorganisation)

AZURE_SUBSCRIPTION_ID Prenumerations-ID:t
Spara varje hemlighet genom att välja Lägg till hemlighet.

GitHub-hemlighet	Active Directory-program
AZURE_CLIENT_ID	App-ID (klient-ID)
AZURE_TENANT_ID	Katalog-ID (klientorganisation)
AZURE_SUBSCRIPTION_ID	Prenumerations-ID:t

Konfigurera GitHub-hemligheter för ditt register

Definiera hemligheter som ska användas med åtgärden Docker-inloggning. Exemplet i det här dokumentet använder Azure Container Registry för containerregistret.

Gå till containern i Azure-portalen eller Docker och kopiera användarnamnet och lösenordet. Du hittar användarnamnet och lösenordet för Azure Container Registry i Azure-portalen under Inställningar>Åtkomstnycklar för ditt register.
Definiera en ny hemlighet för registrets användarnamn med namnet REGISTRY_USERNAME.
Definiera en ny hemlighet för registerlösenordet med namnet REGISTRY_PASSWORD.

Skapa containeravbildningen

I följande exempel visas en del av arbetsflödet som skapar en Node.JS Docker-avbildning. Använd Docker-inloggning för att logga in på ett privat containerregister. I det här exemplet används Azure Container Registry, men samma åtgärd fungerar för andra register.

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}

Du kan också använda Docker-inloggning för att logga in på flera containerregister samtidigt. Det här exemplet innehåller två nya GitHub-hemligheter för autentisering med docker.io. Exemplet förutsätter att det finns en Dockerfile på rotnivån i registret.

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - uses: azure/docker-login@v1
      with:
        login-server: index.docker.io
        username: ${{ secrets.DOCKERIO_USERNAME }}
        password: ${{ secrets.DOCKERIO_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}

Distribuera till en App Service-container

Om du vill distribuera avbildningen till en anpassad container i App Service använder du åtgärden azure/webapps-deploy@v2 . Den här åtgärden har sju parametrar:

Parameter	Förklaring
appnamn	(Krävs) Namnet på App Service-appen
publicera profil	(Valfritt) Gäller för Web Apps (Windows och Linux) och Web App Containers(linux). Scenario med flera containrar stöds inte. Publicera profilfilinnehåll (*.publishsettings) med webbdistributionshemligheter
slot-name	(Valfritt) Ange ett befintligt fack som inte är produktionsplatsen
paket	(Valfritt) Gäller endast för webbapp: Sökväg till paket eller mapp. .zip, .war, *.jar eller en mapp att distribuera
Bilder	(Krävs) Gäller endast för webappcontainrar: Ange det fullständigt kvalificerade containeravbildningsnamnet. Till exempel "myregistry.azurecr.io/nginx:latest" eller "python:3.7.2-alpine/". För en app med flera containrar kan flera containeravbildningsnamn anges (avgränsade med flera rader)
configuration-file	(Valfritt) Gäller endast för webappcontainrar: Sökvägen till Docker-Compose-filen. Bör vara en fullständigt kvalificerad sökväg eller i förhållande till standardarbetskatalogen. Krävs för appar med flera containrar.
startup-command	(Valfritt) Ange startkommandot. För ex. dotnet run eller dotnet filename.dll

name: Linux Container Node Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2

    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}

    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     

    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'

on: [push]

name: Linux_Container_Node_Workflow

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
    
    - name: 'Sign in via Azure CLI'
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
    
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     
      
    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'
    
    - name: Azure logout
      run: |
        az logout

on: [push]
name: Linux_Container_Node_Workflow

permissions:
      id-token: write
      contents: read

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
    
    - name: 'Sign in via Azure CLI'
      uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    
    - uses: azure/docker-login@v1
      with:
        login-server: mycontainer.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}
    - run: |
        docker build . -t mycontainer.azurecr.io/myapp:${{ github.sha }}
        docker push mycontainer.azurecr.io/myapp:${{ github.sha }}     
      
    - uses: azure/webapps-deploy@v2
      with:
        app-name: 'myapp'
        images: 'mycontainer.azurecr.io/myapp:${{ github.sha }}'
    
    - name: Azure logout
      run: |
        az logout

Nästa steg

Du hittar vår uppsättning åtgärder grupperade i olika lagringsplatser på GitHub, där var och en innehåller dokumentation och exempel som hjälper dig att använda GitHub för CI/CD och distribuera dina appar till Azure.

Dela via