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 standardprocessen Skapa webbapp. Ange Kontinuerlig distribution till Aktivera på fliken Distribution och konfigurera den organisation, lagringsplats och gren som du vill använda.

Skärmbild som visar hur du aktiverar GitHub Actions-distribution på fliken Skapa distribution i App Service.

När du aktiverar kontinuerlig distribution väljer appskapandet automatiskt autentiseringsmetoden baserat på det grundläggande autentiseringsvalet och konfigurerar din app och din GitHub-lagringsplats i enlighet med detta:

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

Kommentar

Du kan få ett felmeddelande när du skapar appen som ditt Azure-konto inte har vissa behörigheter. Ditt konto kan behöva 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 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 Connect-autentiseringen med en användartilldelad identitet. Mer information finns i alternativet användartilldelad identitet.

Om ditt Azure-konto har de behörigheter som krävs kan du 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 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

Generera autentiseringsuppgifter för distribution

Det rekommenderade sättet att autentisera med Azure App Services för GitHub Actions är med OpenID Connect. Den här metoden är en autentiseringsmetod som använder kortlivade token. Att konfigurera OpenID Connect 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.

Följande procedur beskriver 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 Portal finns i Ansluta 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 returnerar 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 att använda 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 . GitHub definierar dess värde beroende på ditt arbetsflöde:

      • För 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"
    ]
}

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.

Lägg till arbetsflödesfilen på din GitHub-lagringsplats

En YAML-fil (.yml) i /.github/workflows/ sökvägen i din GitHub-lagringsplats definierar ett arbetsflöde. 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 din kod 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 åtgärden finns i azure/webapps-deploy@v3 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 Connect med den hanterade identitet som du konfigurerade använder azure/login@v1 du åtgärden med client-idnycklarna , tenant-idoch subscription-id . Referera till De GitHub-hemligheter 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?

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 Azure-autentiseringsuppgifter.

    - 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?

Om du föredrar att Azure CLI distribueras till App Service kan du använda GitHub-åtgärden för Azure 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ärd.

Mer information om kommandot az webapp deploy, hur du använder det och parameterinformationen finns i dokumentationen om az webapp deploy.

Hur gör jag för att distribuera en startfil?

Använd GitHub-åtgärden för CLI. Till exempel:

- name: Deploy startup script
  uses: azure/cli@v2
  with:
    inlineScript: |
      az webapp deploy --src-path ${{ github.workspace }}/src/main/azure/createPasswordlessDataSource.sh --name ${{ env.AZURE_WEBAPP_NAME }} --resource-group ${{ env.RESOURCE_GROUP }} --type startup --track-status false

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. Mer information om hur du distribuerar 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 lagringsplatsen För App Service-inställningar .

Relaterat innehåll

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