Dela via

Distribuera till App Service med GitHub Actions

  • Artikel

Kom igång med GitHub Actions för att automatisera arbetsflödet och distribuera till Azure App Service från GitHub.

Förutsättningar

Konfigurera GitHub Actions-distribution när du skapar appen

GitHub Actions-distributionen är integrerad i guiden för att skapa standardappar. Du behöver bara ange Kontinuerlig distribution till Aktivera på fliken Distribution och konfigurera den organisation, lagringsplats och gren som du vill använda.

En skärmbild som visar hur du aktiverar GitHub Actions-distribution i guiden Skapa App Service.

När du aktiverar kontinuerlig distribution väljer guiden för att skapa appar automatiskt autentiseringsmetoden baserat på det grundläggande autentiseringsvalet och konfigurerar appen och GitHub-lagringsplatsen i enlighet med detta:

Grundläggande autentiseringsval Autentiseringsmetod
Inaktivera Användartilldelad identitet (OpenID Anslut) (rekommenderas)
Aktivera Grundläggande autentisering

Kommentar

Om du får ett felmeddelande när du skapar din app som säger att ditt Azure-konto inte har vissa behörigheter kanske det inte har de behörigheter som krävs för att skapa och konfigurera den användartilldelade identiteten. Ett alternativ finns i Konfigurera GitHub Actions-distribution från Distributionscenter.

Konfigurera GitHub Actions-distribution från Distributionscenter

För en befintlig app kan du komma igång snabbt med GitHub Actions med hjälp av App Service Deployment Center. Den här nyckelnyckelmetoden genererar automatiskt en GitHub Actions-arbetsflödesfil baserat på din programstack och checkar in den på din GitHub-lagringsplats.

Med Distributionscenter kan du också enkelt konfigurera den säkrare OpenID-Anslut-autentiseringen med det användartilldelade identitetsalternativet.

Om ditt Azure-konto har de behörigheter som krävs kan du välja att skapa en användartilldelad identitet. Annars kan du välja en befintlig användartilldelad hanterad identitet i listrutan Identitet . Du kan samarbeta med Azure-administratören för att skapa en användartilldelad hanterad identitet med rollen Webbplatsdeltagare.

Mer information finns i Kontinuerlig distribution till Azure App Service.

Konfigurera ett GitHub Actions-arbetsflöde manuellt

Du kan också distribuera ett arbetsflöde utan att använda Distributionscenter. I så fall måste du utföra tre steg:

  1. Generera autentiseringsuppgifter för distribution
  2. Konfigurera GitHub-hemligheten
  3. Lägg till arbetsflödesfilen på din GitHub-lagringsplats

1. Generera autentiseringsuppgifter för distribution

Det rekommenderade sättet att autentisera med Azure App Services för GitHub Actions är med OpenID Anslut. Det här är en autentiseringsmetod som använder kortlivade token. Att konfigurera OpenID-Anslut med GitHub Actions är mer komplext men ger förstärkt säkerhet.

Du kan också autentisera med en användartilldelad hanterad identitet, ett huvudnamn för tjänsten eller en publiceringsprofil.

Nedan går du igenom stegen för att skapa ett Active Directory-program, tjänstens huvudnamn och federerade autentiseringsuppgifter med hjälp av Azure CLI-instruktioner. Information om hur du skapar ett Active Directory-program, tjänstens huvudnamn och federerade autentiseringsuppgifter i Azure-portalen finns i Anslut GitHub och Azure.

  1. 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 en 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.

  2. 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

  3. 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, $webappName med webbappens namn och $assigneeObjectId med det genererade id. Lär dig hur du hanterar Azure-prenumerationer med Azure CLI.

    az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/$webappName --assignee-principal-type ServicePrincipal

  4. 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 appId (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 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 ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
("credential.json" contains the following content)
{
    "name": "<CREDENTIAL-NAME>",
    "issuer": "https://token.actions.githubusercontent.com",
    "subject": "repo:organization/repository:ref:refs/heads/main",
    "description": "Testing",
    "audiences": [
        "api://AzureADTokenExchange"
    ]
}

2. Konfigurera GitHub-hemligheten

Du måste ange programmets klient-ID, klient-ID och prenumerations-ID till Azure-/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.

  1. Öppna din GitHub-lagringsplats och gå till Inställningar Säkerhetshemligheter > och variabler > Åtgärder > Ny lagringsplatshemlighet>.

  2. 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:

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

  3. Spara varje hemlighet genom att välja Lägg till hemlighet.

3. Lägg till arbetsflödesfilen till din GitHub-lagringsplats

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

Arbetsflödesfilen har minst följande distinkta steg:

  1. Autentisera med App Service med hjälp av GitHub-hemligheten som du skapade.
  2. Skapa webbappen.
  3. Distribuera webbappen.

Om du vill distribuera koden till en App Service-app använder du åtgärden azure/webapps-deploy@v3 . Åtgärden kräver namnet på webbappen i app-name och, beroende på din språkstack, sökvägen till en *.zip, *.war, *.jar eller mapp som ska distribueras i package. En fullständig lista över möjliga indata för azure/webapps-deploy@v3 åtgärden finns i definitionen action.yml .

I följande exempel visas den del av arbetsflödet som skapar webbappen på olika språk som stöds.

Om du vill distribuera med OpenID Anslut med den hanterade identitet som du konfigurerade använder azure/login@v1 du åtgärden med client-idnycklarna , tenant-idoch subscription-id och refererar till GitHub-hemligheterna som du skapade tidigare.

name: .NET Core

on: [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      - uses: azure/login@v1
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using publish profile credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
      
      - name: logout
        run: |
          az logout

Vanliga frågor och svar

Hur gör jag för att distribuera en WAR-fil via Maven-plugin-programmet och OpenID-Anslut

Om du har konfigurerat ditt Java Tomcat-projekt med Maven-plugin-programmet kan du även distribuera till Azure App Service via det här plugin-programmet. Om du använder Azure CLI GitHub-åtgärden använder den dina autentiseringsuppgifter för Azure-inloggning.

    - name: Azure CLI script file
      uses: azure/cli@v2
      with:
        inlineScript: |
          mvn package azure-webapp:deploy

Mer information om Plugin-programmet Maven och hur du använder och konfigurerar det finns i Maven-plugin-wikin för Azure App Service.

Hur gör jag för att distribuera en WAR-fil via Az CLI och OpenID Anslut

Om du föredrar att Azure CLI distribueras till App Service kan du använda GitHub-åtgärden för CLI.

    - name: Azure CLI script
      uses: azure/cli@v2
      with:
        inlineScript: |
          az webapp deploy --src-path '${{ github.workspace }}/target/yourpackage.war' --name ${{ env.AZURE_WEBAPP_NAME }} --resource-group ${{ env.RESOURCE_GROUP }}  --async true --type war

Mer information om GitHub-åtgärden för CLI och hur du använder och konfigurerar den finns i Azure CLI GitHub-åtgärden. Mer information om kommandot az webapp deploy, how to use och parameterinformation finns i dokumentationen för az webapp deploy.

Hur gör jag för att distribuera till en container

Med åtgärden Azure Web Deploy kan du automatisera arbetsflödet för att distribuera anpassade containrar till App Service med GitHub Actions. Detaljerad information om stegen för att distribuera med GitHub Actions finns i Distribuera till en container.

Hur gör jag för att uppdatera Tomcat-konfigurationen efter distributionen

Om du vill uppdatera någon av dina inställningar för webbappar efter distributionen kan du använda åtgärden App Service Inställningar.

    - uses: azure/appservice-settings@v1
      with:
        app-name: 'my-app'
        slot-name: 'staging'  # Optional and needed only if the settings have to be configured on the specific deployment slot
        app-settings-json: '[{ "name": "CATALINA_OPTS", "value": "-Dfoo=bar" }]' 
        connection-strings-json: '${{ secrets.CONNECTION_STRINGS }}'
        general-settings-json: '{"alwaysOn": "false", "webSocketsEnabled": "true"}' #'General configuration settings as Key Value pairs'
      id: settings

Mer information om den här åtgärden och hur du använder och konfigurerar den finns i App Service Inställningar-lagringsplatsen.

Nästa steg

Kolla in referenser på Azure GitHub Actions och arbetsflöden: