Kontinuerlig leverans med hjälp av GitHub Actions

Artikel
04/07/2024

Du kan använda ett GitHub Actions-arbetsflöde för att definiera ett arbetsflöde för att automatiskt skapa och distribuera kod till funktionsappen i Azure Functions.

En YAML-fil (.yml) som definierar arbetsflödeskonfigurationen /.github/workflows/ underhålls i sökvägen på lagringsplatsen. Den här definitionen innehåller de åtgärder och parametrar som utgör arbetsflödet, vilket är specifikt för utvecklingsspråket för dina funktioner. Ett GitHub Actions-arbetsflöde för Functions utför följande uppgifter, oavsett språk:

Konfigurera miljön.
Skapa kodprojektet.
Distribuera paketet till en funktionsapp i Azure.

Azure Functions-åtgärden hanterar distributionen till en befintlig funktionsapp i Azure.

Du kan skapa en arbetsflödeskonfigurationsfil för distributionen manuellt. Du kan också generera filen från en uppsättning språkspecifika mallar på något av följande sätt:

I Azure-portalen
Använda Azure CLI
Från din GitHub-lagringsplats

Om du inte vill skapa YAML-filen för hand väljer du en annan metod överst i artikeln.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
Ett GitHub-konto. Om du inte har ett sådant kan du registrera dig utan kostnad.
En fungerande funktionsapp som finns i Azure med källkod på en GitHub-lagringsplats.

Azure CLI, när du utvecklar lokalt. Du kan också använda Azure CLI i Azure Cloud Shell.

Generera autentiseringsuppgifter för distribution

Eftersom GitHub Actions använder din publiceringsprofil för att komma åt funktionsappen under distributionen måste du först hämta din publiceringsprofil och lagra den på ett säkert sätt som en GitHub-hemlighet.

Viktigt!

Publiceringsprofilen är en värdefull autentiseringsuppgift som ger åtkomst till Azure-resurser. Se till att du alltid transporterar och lagrar den säkert. I GitHub får publiceringsprofilen endast lagras i GitHub-hemligheter.

Ladda ned din publiceringsprofil

Så här laddar du ned publiceringsprofilen för funktionsappen:

Välj funktionsappens översiktssida och välj sedan Hämta publiceringsprofil.
Spara och kopiera innehållet i filen.

Lägg till GitHub-hemligheten

Gå till din lagringsplats i GitHub.
Gå till inställningar.
Välj Hemligheter och variabler > Åtgärder.
Välj Ny lagringsplatshemlighet.
Lägg till en ny hemlighet med namnet AZURE_FUNCTIONAPP_PUBLISH_PROFILE och värdet inställt på innehållet i publiceringsprofilfilen.
Välj Add secret (Lägg till hemlighet).

GitHub kan nu autentisera till din funktionsapp i Azure.

Skapa arbetsflödet från en mall

Det bästa sättet att skapa en arbetsflödeskonfiguration manuellt är att börja från mallen som stöds officiellt.

Skapa arbetsflödeskonfigurationen i portalen

När du använder portalen för att aktivera GitHub Actions skapar Functions en arbetsflödesfil baserat på programstacken och checkar in den på din GitHub-lagringsplats i rätt katalog.

Portalen hämtar automatiskt din publiceringsprofil och lägger till den i GitHub-hemligheterna för din lagringsplats.

Under funktionsappens skapande

Du kan komma igång snabbt med GitHub Actions via fliken Distribution när du skapar en funktion i Azure-portalen. Så här lägger du till ett GitHub Actions-arbetsflöde när du skapar en ny funktionsapp:

I Azure-portalen väljer du Distribution i flödet Skapa funktionsapp.
Aktivera kontinuerlig distribution om du vill att varje koduppdatering ska utlösa en kod-push till Azure-portalen.
Ange din GitHub-organisation, lagringsplats och gren.
Slutför konfigurationen av funktionsappen. GitHub-lagringsplatsen innehåller nu en ny arbetsflödesfil i /.github/workflows/.

För en befintlig funktionsapp

Så här lägger du till ett GitHub Actions-arbetsflöde i en befintlig funktionsapp:

Gå till funktionsappen i Azure-portalen och välj Distributionscenter.
För Källa väljer du GitHub. Om du inte ser standardmeddelandet Skapa med GitHub Actions väljer du Ändra provider , väljer GitHub Actions och väljer OK.
Om du inte redan har auktoriserad GitHub-åtkomst väljer du Auktorisera. Ange dina GitHub-autentiseringsuppgifter och välj Logga in. Om du vill auktorisera ett annat GitHub-konto väljer du Ändra konto och loggar in med ett annat konto.
Välj din GitHub-organisation, lagringsplats och gren. Om du vill distribuera med GitHub Actions måste du ha skrivåtkomst till den här lagringsplatsen.
I Autentiseringsinställningar väljer du om GitHub Actions ska autentiseras med en användartilldelad identitet eller använda grundläggande autentiseringsuppgifter . För grundläggande autentisering används de aktuella autentiseringsuppgifterna.
Välj Förhandsgranskningsfil för att se arbetsflödesfilen som läggs till i GitHub-lagringsplatsen i github/workflows/.
Välj Spara för att lägga till arbetsflödesfilen på lagringsplatsen.

Lägga till arbetsflödeskonfiguration på lagringsplatsen

Du kan använda az functionapp deployment github-actions add kommandot för att generera en arbetsflödeskonfigurationsfil från rätt mall för funktionsappen. Den nya YAML-filen lagras sedan på rätt plats (/.github/workflows/) på den GitHub-lagringsplats som du anger, medan publiceringsprofilfilen för din app läggs till i GitHub-hemligheter på samma lagringsplats.

Kör det här az functionapp kommandot och ersätt värdena githubUser/githubRepo, MyResourceGroupoch MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Det här kommandot använder en interaktiv metod för att hämta en personlig åtkomsttoken för ditt GitHub-konto.

I terminalfönstret bör du se något som liknar följande meddelande:

Please navigate to https://github.com/login/device and enter the user code XXXX-XXXX to activate and retrieve your GitHub personal access token.

Kopiera den unika XXXX-XXXX koden, bläddra till https://github.com/login/deviceoch ange den kod som du kopierade. När du har angett koden bör du se något som liknar följande meddelande:

Verified GitHub repo and branch
Getting workflow template using runtime: java
Filling workflow template with name: func-app-123, branch: main, version: 8, slot: production, build_path: .
Adding publish profile to GitHub
Fetching publish profile with secrets for the app 'func-app-123'
Creating new workflow file: .github/workflows/master_func-app-123.yml

Gå till din GitHub-lagringsplats och välj Åtgärder. Kontrollera att arbetsflödet kördes.

Skapa arbetsflödeskonfigurationsfilen

Du kan skapa konfigurationsfilen för GitHub Actions-arbetsflödet från Azure Functions-mallarna direkt från din GitHub-lagringsplats.

Gå till din lagringsplats i GitHub.
Välj Åtgärder och Nytt arbetsflöde.
Sök efter funktioner.
I de funktionsapparbetsflöden som visas som skapats av Microsoft Azure letar du reda på det som matchar ditt kodspråk och väljer Konfigurera.
I den nyligen skapade YAML-filen uppdaterar du parametern env.AZURE_FUNCTIONAPP_NAME med namnet på funktionsappresursen i Azure. Du kan också behöva uppdatera parametern som anger språkversionen som används av din app, till exempel DOTNET_VERSION för C#.
Kontrollera att den nya arbetsflödesfilen sparas i /.github/workflows/ och välj Checka in ändringar....

Uppdatera en arbetsflödeskonfiguration

Om du av någon anledning behöver uppdatera eller ändra en befintlig arbetsflödeskonfiguration går du bara till platsen /.github/workflows/ på lagringsplatsen, öppnar den specifika YAML-filen, gör nödvändiga ändringar och genomför sedan uppdateringarna till lagringsplatsen.

Exempel: konfigurationsfil för arbetsflöde

I följande mallexempel används version 1 av functions-action och en publish profile för autentisering. Mallen beror på ditt valda språk och det operativsystem som funktionsappen distribueras på:

Windows
Linux

Om din funktionsapp körs på Linux väljer du Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Azure Functions-åtgärd

Azure Functions-åtgärden (Azure/azure-functions) definierar hur koden publiceras till en befintlig funktionsapp i Azure eller till ett specifikt fack i din app.

Parametrar

Följande parametrar används oftast med den här åtgärden:

Parameter	Förklaring
appnamn	(Obligatoriskt) Namnet på funktionsappen.
slot-name	(Valfritt) Namnet på ett specifikt distributionsfack som du vill distribuera till. Facket måste redan finnas i funktionsappen. När koden inte har angetts distribueras den till det aktiva facket.
publicera profil	(Valfritt) Namnet på GitHub-hemligheten som innehåller din publiceringsprofil.

Följande parametrar stöds också, men används endast i specifika fall:

Parameter	Förklaring
Paket	(Valfritt) Anger en undersökväg i lagringsplatsen som du vill publicera från. Som standard är det här värdet inställt på , vilket innebär att `.`alla filer och mappar i GitHub-lagringsplatsen distribueras.
respect-pom-xml	(Valfritt) Används endast för Java-funktioner. Om det krävs för att appens distributionsartefakt ska härledas från filen pom.xml. När du distribuerar Java-funktionsappar bör du ange den här parametern till `true` och inställd `package` på `.`. Som standard är den här parametern inställd på `false`, vilket innebär att parametern `package` måste peka på appens artefaktplats, till exempel `./target/azure-functions/`
respect-funcignore	(Valfritt) Om GitHub Actions respekterar .funcignore-filen för att undanta filer och mappar som definierats i den. Ange det här värdet till `true` när lagringsplatsen har en .funcignore-fil och du vill använda den för att exkludera sökvägar och filer, till exempel textredigerarens konfigurationer, .vscode/eller en virtuell Python-miljö (.venv/). Standardinställningen är `false`.
scm-do-build-during-deployment	(Valfritt) Om App Service-distributionsplatsen (Kudu) utför fördistributionsåtgärder. Distributionsplatsen för funktionsappen finns på `https://<APP_NAME>.scm.azurewebsites.net/`. Ändra den här inställningen till `true` när du behöver styra distributionerna i Kudu i stället för att matcha beroendena i GitHub Actions-arbetsflödet. Standardvärdet är `false`. Mer information finns i inställningen SCM_DO_BUILD_DURING_DEPLOYMENT .
enable-oryx-build	(Valfritt) Om Kudu-distributionsplatsen löser dina projektberoenden med hjälp av Oryx. Ange till `true` när du vill använda Oryx för att lösa projektberoenden med hjälp av en fjärrversion i stället för GitHub Actions-arbetsflödet. När `true`bör du också ange `scm-do-build-during-deployment` till `true`. Standardvärdet är `false`.

Att tänka på

Tänk på följande när du använder Azure Functions-åtgärden:

När du använder GitHub Actions distribueras koden till din funktionsapp med zip-distribution för Azure Functions.
De autentiseringsuppgifter som krävs av GitHub för anslutning till Azure för distribution lagras som hemligheter i din GitHub-lagringsplats och används i distributionen som secrets.<SECRET_NAME>.
Det enklaste sättet för GitHub Actions att autentisera med Azure Functions för distribution är genom att använda en publiceringsprofil. Du kan också autentisera med hjälp av ett huvudnamn för tjänsten. Mer information finns i den här GitHub Actions-lagringsplatsen.
Åtgärderna för att konfigurera miljön och köra en version genereras från mallarna och är språkspecifika.
Mallarna använder env element för att definiera inställningar som är unika för din version och distribution.

Nästa steg

Läs mer om Azure- och GitHub-integrering

Dela via