Ciągłe dostarczanie przy użyciu funkcji GitHub Actions

Możesz użyć przepływu pracy funkcji GitHub Actions, aby zdefiniować przepływ pracy w celu automatycznego kompilowania i wdrażania kodu w aplikacji funkcji w usłudze Azure Functions.

Plik YAML (.yml), który definiuje konfigurację przepływu pracy, jest przechowywany w /.github/workflows/ ścieżce w repozytorium. Ta definicja zawiera akcje i parametry tworzące przepływ pracy, który jest specyficzny dla języka programowania funkcji. Przepływ pracy funkcji GitHub Actions wykonuje następujące zadania niezależnie od języka:

1. Konfigurowanie środowiska.
2. Skompiluj projekt kodu.
3. Wdróż pakiet w aplikacji funkcji na platformie Azure.

Akcja usługi Azure Functions obsługuje wdrożenie w istniejącej aplikacji funkcji na platformie Azure.

Możesz ręcznie utworzyć plik konfiguracji przepływu pracy dla wdrożenia. Plik można również wygenerować na podstawie zestawu szablonów specyficznych dla języka w jeden z następujących sposobów:

• W witrynie Azure Portal
• Przy użyciu interfejsu wiersza polecenia platformy Azure
• Z repozytorium GitHub

Jeśli nie chcesz ręcznie tworzyć pliku YAML, wybierz inną metodę w górnej części artykułu.

Wymagania wstępne

• Konto platformy Azure z aktywną subskrypcją. Utwórz konto bezpłatnie.

• Konto usługi GitHub. Jeśli nie masz takiego konta, zarejestruj się bezpłatnie.

• Działająca aplikacja funkcji hostowana na platformie Azure z kodem źródłowym w repozytorium GitHub.

• Interfejs wiersza polecenia platformy Azure podczas opracowywania lokalnie. Możesz również użyć interfejsu wiersza polecenia platformy Azure w usłudze Azure Cloud Shell.

Generowanie poświadczeń wdrożenia

Ponieważ funkcja GitHub Actions używa profilu publikowania do uzyskiwania dostępu do aplikacji funkcji podczas wdrażania, najpierw musisz pobrać profil publikowania i bezpiecznie zapisać go jako wpis tajny usługi GitHub.

Ważne

Profil publikowania to cenne poświadczenia umożliwiające dostęp do zasobów platformy Azure. Upewnij się, że zawsze transportujesz i przechowujesz go bezpiecznie. W usłudze GitHub profil publikowania musi być przechowywany tylko w wpisach tajnych usługi GitHub.

Pobieranie profilu publikowania

Aby pobrać profil publikowania aplikacji funkcji:

1. W witrynie Azure Portal znajdź stronę aplikacji funkcji, rozwiń węzeł Konfiguracja ustawień>w lewej kolumnie.

2. Na stronie Konfiguracja wybierz kartę Ustawienia ogólne i upewnij się, że poświadczenia publikowania uwierzytelniania podstawowego programu SCM są włączone. Jeśli to ustawienie jest wyłączone, nie można używać profilów publikowania, dlatego wybierz pozycję Włączone, a następnie pozycję Zapisz.

3. Wróć do strony Przegląd aplikacji funkcji, a następnie wybierz pozycję Pobierz profil publikowania.

   

4. Zapisz i skopiuj zawartość pliku.

Dodawanie wpisu tajnego usługi GitHub

1. W usłudze GitHub przejdź do repozytorium.

2. Przejdź do ustawień.

3. Wybierz pozycję Wpisy tajne i zmienne > Akcje.

4. Wybierz pozycję Nowy wpis tajny repozytorium.

5. Dodaj nowy wpis tajny o nazwie AZURE_FUNCTIONAPP_PUBLISH_PROFILE i wartości ustawionej na zawartość pliku profilu publikowania.

6. Wybierz przycisk Add secret (Dodaj wpis tajny).

Usługa GitHub może teraz uwierzytelniać się w aplikacji funkcji na platformie Azure.

Tworzenie przepływu pracy na podstawie szablonu

Najlepszym sposobem ręcznego utworzenia konfiguracji przepływu pracy jest rozpoczęcie od oficjalnie obsługiwanego szablonu.

1. Wybierz system Windows lub Linux , aby upewnić się, że masz szablon odpowiedniego systemu operacyjnego.

   Windows

   Wdrożenia w systemie Windows używają polecenia runs-on: windows-latest.

   Linux

   Wdrożenia w systemie Linux używają polecenia runs-on: ubuntu-latest.

2. Skopiuj szablon specyficzny dla języka z repozytorium akcji usługi Azure Functions, korzystając z następującego linku:

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-dotnet-functionapp-on-azure.yml

   .NET

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-dotnet-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-java-functionapp-on-azure.yml

   Java

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-java-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-node.js-functionapp-on-azure.yml

   JavaScript

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-node.js-functionapp-on-azure.yml

   Python

   Funkcje języka Python nie są obsługiwane w systemie Windows. Zamiast tego wybierz pozycję Linux.

   Python

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-python-functionapp-on-azure.yml

   Program PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/windows-powershell-functionapp-on-azure.yml

   Program PowerShell

   https://github.com/Azure/actions-workflow-samples/blob/master/FunctionApp/linux-powershell-functionapp-on-azure.yml

3. env.AZURE_FUNCTIONAPP_NAME Zaktualizuj parametr przy użyciu nazwy zasobu aplikacji funkcji na platformie Azure. Opcjonalnie może być konieczne zaktualizowanie parametru, który ustawia wersję języka używaną przez aplikację, na przykład DOTNET_VERSION dla języka C#.

4. Dodaj ten nowy plik YAML w /.github/workflows/ ścieżce w repozytorium.

Tworzenie konfiguracji przepływu pracy w portalu

Gdy używasz portalu do włączania funkcji GitHub Actions, usługa Functions tworzy plik przepływu pracy na podstawie stosu aplikacji i zatwierdza go w repozytorium GitHub we właściwym katalogu.

Portal automatycznie pobiera profil publikowania i dodaje go do wpisów tajnych usługi GitHub dla repozytorium.

Podczas tworzenia aplikacji funkcji

Możesz szybko rozpocząć pracę z funkcją GitHub Actions za pomocą karty Wdrażanie podczas tworzenia funkcji w witrynie Azure Portal. Aby dodać przepływ pracy funkcji GitHub Actions podczas tworzenia nowej aplikacji funkcji:

1. W witrynie Azure Portal wybierz pozycję Wdrożenie w przepływie Tworzenie aplikacji funkcji.

   

2. Włącz ciągłe wdrażanie , jeśli chcesz, aby każda aktualizacja kodu wyzwalała wypychanie kodu do witryny Azure Portal.

3. Wprowadź organizację, repozytorium i gałąź usługi GitHub.

   

4. Zakończ konfigurowanie aplikacji funkcji. Repozytorium GitHub zawiera teraz nowy plik przepływu pracy w pliku /.github/workflows/.

W przypadku istniejącej aplikacji funkcji

Aby dodać przepływ pracy funkcji GitHub Actions do istniejącej aplikacji funkcji:

1. Przejdź do aplikacji funkcji w witrynie Azure Portal i wybierz pozycję Centrum wdrażania.

2. W polu Źródło wybierz pozycję GitHub. Jeśli nie widzisz domyślnego komunikatu Kompilowanie za pomocą funkcji GitHub Actions, wybierz pozycję Zmień dostawcę wybierz pozycję GitHub Actions i wybierz przycisk OK.

3. Jeśli nie masz jeszcze autoryzowanego dostępu do usługi GitHub, wybierz pozycję Autoryzuj. Podaj poświadczenia usługi GitHub i wybierz pozycję Zaloguj się. Aby autoryzować inne konto usługi GitHub, wybierz pozycję Zmień konto i zaloguj się przy użyciu innego konta.

4. Wybierz swoją organizację, repozytorium i gałąź GitHub. Aby wdrożyć za pomocą funkcji GitHub Actions, musisz mieć dostęp do zapisu w tym repozytorium.

5. W obszarze Ustawienia uwierzytelniania wybierz, czy funkcja GitHub Actions ma być uwierzytelniana przy użyciu tożsamości przypisanej przez użytkownika, czy przy użyciu poświadczeń uwierzytelniania podstawowego. W przypadku uwierzytelniania podstawowego używane są bieżące poświadczenia.

6. Wybierz pozycję Plik podglądu, aby wyświetlić plik przepływu pracy, który zostanie dodany do repozytorium GitHub w programie github/workflows/.

7. Wybierz pozycję Zapisz , aby dodać plik przepływu pracy do repozytorium.

Dodawanie konfiguracji przepływu pracy do repozytorium

Możesz użyć az functionapp deployment github-actions add polecenia , aby wygenerować plik konfiguracji przepływu pracy na podstawie poprawnego szablonu dla aplikacji funkcji. Nowy plik YAML jest następnie przechowywany w prawidłowej lokalizacji (/.github/workflows/) w podanym repozytorium GitHub, podczas gdy plik profilu publikowania aplikacji jest dodawany do wpisów tajnych usługi GitHub w tym samym repozytorium.

1. Uruchom to az functionapp polecenie, zastępując wartości githubUser/githubRepo, MyResourceGroupi MyFunctionapp:

   az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
   

   To polecenie używa metody interaktywnej do pobierania osobistego tokenu dostępu dla konta usługi GitHub.

2. W oknie terminalu powinien zostać wyświetlony komunikat podobny do następującego:

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

3. Skopiuj unikatowy XXXX-XXXX kod, przejdź do https://github.com/login/deviceadresu i wprowadź skopiowany kod. Po wprowadzeniu kodu powinien zostać wyświetlony komunikat podobny do następującego:

   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
   

4. Przejdź do repozytorium GitHub i wybierz pozycję Akcje. Sprawdź, czy przepływ pracy został uruchomiony.

Tworzenie pliku konfiguracji przepływu pracy

Plik konfiguracji przepływu pracy funkcji GitHub Actions można utworzyć na podstawie szablonów usługi Azure Functions bezpośrednio z repozytorium GitHub.

1. W usłudze GitHub przejdź do repozytorium.

2. Wybierz pozycję Akcje i Nowy przepływ pracy.

3. Wyszukaj funkcje.

   

4. W wyświetlonych przepływach pracy aplikacji funkcji utworzonych przez platformę Microsoft Azure znajdź ten, który jest zgodny z językiem kodu, a następnie wybierz pozycję Konfiguruj.

5. W nowo utworzonym pliku YAML zaktualizuj env.AZURE_FUNCTIONAPP_NAME parametr przy użyciu nazwy zasobu aplikacji funkcji na platformie Azure. Opcjonalnie może być konieczne zaktualizowanie parametru, który ustawia wersję języka używaną przez aplikację, na przykład DOTNET_VERSION dla języka C#.

6. Sprawdź, czy nowy plik przepływu pracy jest zapisywany, /.github/workflows/ a następnie wybierz pozycję Zatwierdź zmiany....

Aktualizowanie konfiguracji przepływu pracy

Jeśli z jakiegoś powodu musisz zaktualizować lub zmienić istniejącą konfigurację przepływu pracy, po prostu przejdź do /.github/workflows/ lokalizacji w repozytorium, otwórz konkretny plik YAML, wprowadź wymagane zmiany, a następnie zatwierdź aktualizacje w repozytorium.

Przykład: plik konfiguracji przepływu pracy

W poniższym przykładzie szablonu użyto wersji 1 elementu functions-action i dla publish profile uwierzytelniania. Szablon zależy od wybranego języka i systemu operacyjnego, na którym wdrożono aplikację funkcji:

Windows

Jeśli aplikacja funkcji działa w systemie Linux, wybierz pozycję Linux.

Linux

Jeśli aplikacja funkcji działa w systemie Windows, wybierz pozycję Windows.

.NET

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

.NET

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

Java

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

Java

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

JavaScript

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

JavaScript

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

Python

Funkcje języka Python nie są obsługiwane w systemie Windows. Zamiast tego wybierz pozycję Linux.

Python

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

Program PowerShell

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

Program PowerShell

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

Akcja usługi Azure Functions

Akcja usługi Azure Functions (Azure/azure-functions) definiuje sposób publikowania kodu w istniejącej aplikacji funkcji na platformie Azure lub do określonego miejsca w aplikacji.

Parametry

Dla wszystkich planów aplikacji funkcji wymagane są następujące parametry:

Parametr	Wyjaśnienie
nazwa aplikacji	Nazwa aplikacji funkcji.
pakiet	Jest to lokalizacja w projekcie, która ma zostać opublikowana. Domyślnie ta wartość jest ustawiona na .wartość , co oznacza, że zostaną wdrożone wszystkie pliki i foldery w repozytorium GitHub.

Dla planu Flex Consumption są wymagane następujące parametry:

Parametr	Wyjaśnienie
Numer jednostki magazynowej	Ustaw wartość na flexconsumption wartość podczas uwierzytelniania za pomocą profilu publikowania. W przypadku korzystania z poświadczeń RBAC lub wdrażania w planie innego niż Flex Consumption akcja może rozpoznać wartość, więc parametr nie musi być uwzględniony.
zdalne kompilowanie	Ustaw tę true opcję na wartość , aby włączyć akcję kompilacji z usługi Kudu, gdy pakiet zostanie wdrożony w aplikacji Flex Consumption. Kompilacja Oryx jest zawsze wykonywana podczas zdalnej kompilacji w rozwiązaniu Flex Consumption; nie należy ustawiać polecenia scm-do-build-during-deployment lub enable-oryx-build. Domyślnie ten parametr ma wartość false.

Następujące parametry są specyficzne dla planów Consumption, Elastic Premium i App Service (Dedicated):

Parametr	Wyjaśnienie
scm-do-build-during-deployment	(Opcjonalnie) Zezwól lokacji Kudu (np. https://<APP_NAME>.scm.azurewebsites.net/) na wykonywanie operacji przed wdrożeniem, takich jak kompilacje zdalne. Domyślnie jest to ustawiona wartość false. Ustaw tę wartość na true , gdy chcesz kontrolować zachowania wdrażania przy użyciu narzędzia Kudu zamiast rozpoznawać zależności w przepływie pracy usługi GitHub. Aby uzyskać więcej informacji, zobacz SCM_DO_BUILD_DURING_DEPLOYMENT ustawienie.
enable-oryx-build	(Opcjonalnie) Zezwól witrynie Kudu na rozwiązywanie zależności projektu za pomocą rozwiązania Oryx. Domyślnie jest to ustawiona wartość false. Jeśli chcesz użyć narzędzia Oryx , aby rozwiązać problemy z zależnościami zamiast przepływu pracy usługi GitHub, ustaw parametr scm-do-build-during-deployment i enable-oryx-build na truewartość .

Opcjonalne parametry dla wszystkich planów aplikacji funkcji:

Parametr	Wyjaśnienie
nazwa miejsca	Jest to nazwa miejsca wdrożenia, w którym ma zostać wdrożona. Domyślnie ta wartość jest pusta, co oznacza, że akcja usługi GitHub zostanie wdrożona w lokacji produkcyjnej. Jeśli to ustawienie wskazuje miejsce nieprodukcyjne, upewnij się, że parametr publish-profile zawiera poświadczenia dla miejsca zamiast lokacji produkcyjnej. Obecnie nieobsługiwane w rozwiązaniu Flex Consumption.
profil publikowania	Nazwa wpisu tajnego usługi GitHub zawierającego profil publikowania.
respect-pom-xml	Używane tylko w przypadku funkcji Języka Java. Czy jest to wymagane, aby artefakt wdrożenia aplikacji był uzyskiwany z pliku pom.xml. Podczas wdrażania aplikacji funkcji Języka Java należy ustawić ten parametr na true wartość i ustawić wartość package .. Domyślnie ten parametr jest ustawiony na falsewartość , co oznacza, że package parametr musi wskazywać lokalizację artefaktu aplikacji, taką jak ./target/azure-functions/
respect-funcignore	Czy funkcja GitHub Actions honoruje plik .funcignore w celu wykluczenia plików i folderów zdefiniowanych w nim. Ustaw tę wartość na true , gdy repozytorium ma plik .funcignore i chcesz użyć go wykluczać ścieżki i pliki, takie jak konfiguracje edytora tekstów, .vscode/lub środowisko wirtualne języka Python (.venv/). Ustawienie domyślne to false.

Kwestie wymagające rozważenia

Podczas korzystania z akcji usługi Azure Functions należy wziąć pod uwagę następujące kwestie:

• W przypadku korzystania z funkcji GitHub Actions kod jest wdrażany przy użyciu jednego wdrożenia w aplikacjach w planie Flex Consumption i zip w aplikacjach w planach Zużycie, Elastic Premium i Dedicated (App Service). Wyjątkiem jest użycie systemu Linux, w którym jest używany zewnętrzny adres URL pakietu.

• Poświadczenia wymagane przez usługę GitHub do nawiązania połączenia z platformą Azure na potrzeby wdrożenia są przechowywane jako wpisy tajne w repozytorium GitHub i dostępne we wdrożeniu jako secrets.<SECRET_NAME>.

• Najprostszym sposobem uwierzytelniania w usłudze GitHub Actions w usłudze Azure Functions na potrzeby wdrożenia jest użycie profilu publikowania. Możesz również uwierzytelnić się przy użyciu jednostki usługi. Aby dowiedzieć się więcej, zobacz to repozytorium funkcji GitHub Actions.

• Akcje konfigurowania środowiska i uruchamiania kompilacji są generowane na podstawie szablonów i są specyficzne dla języka.

• Szablony używają env elementów do definiowania ustawień unikatowych dla kompilacji i wdrożenia.

Następne kroki

Dowiedz się więcej o integracji z platformą Azure i usługą GitHub