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

Artykuł
04/07/2024

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:

Konfigurowanie środowiska.
Skompiluj projekt kodu.
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:

Wybierz stronę Przegląd aplikacji funkcji, a następnie wybierz pozycję Pobierz profil publikowania.
Zapisz i skopiuj zawartość pliku.

Dodawanie wpisu tajnego usługi GitHub

W usłudze GitHub przejdź do repozytorium.
Przejdź do ustawień.
Wybierz pozycję Wpisy tajne i zmienne > Akcje.
Wybierz pozycję Nowy wpis tajny repozytorium.
Dodaj nowy wpis tajny o nazwie AZURE_FUNCTIONAPP_PUBLISH_PROFILE i wartości ustawionej na zawartość pliku profilu publikowania.
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.

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:

W witrynie Azure Portal wybierz pozycję Wdrożenie w przepływie Tworzenie aplikacji funkcji.
Włącz ciągłe wdrażanie , jeśli chcesz, aby każda aktualizacja kodu wyzwalała wypychanie kodu do witryny Azure Portal.
Wprowadź organizację, repozytorium i gałąź usługi GitHub.
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:

Przejdź do aplikacji funkcji w witrynie Azure Portal i wybierz pozycję Centrum wdrażania.
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.
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.
Wybierz swoją organizację, repozytorium i gałąź GitHub. Aby wdrożyć za pomocą funkcji GitHub Actions, musisz mieć dostęp do zapisu w tym repozytorium.
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.
Wybierz pozycję Plik podglądu, aby wyświetlić plik przepływu pracy, który zostanie dodany do repozytorium GitHub w programie github/workflows/.
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.

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.

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.

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

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.

W usłudze GitHub przejdź do repozytorium.
Wybierz pozycję Akcje i Nowy przepływ pracy.
Wyszukaj funkcje.
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.
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#.
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
Linux

Jeśli aplikacja funkcji działa w systemie Linux, wybierz pozycję 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 }}

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

Następujące parametry są najczęściej używane z tą akcją:

Parametr	Wyjaśnienie
nazwa aplikacji	(Obowiązkowe) Nazwa aplikacji funkcji.
nazwa miejsca	(Opcjonalnie) Nazwa określonego miejsca wdrożenia, do którego chcesz wdrożyć. Miejsce musi już istnieć w aplikacji funkcji. Jeśli nie zostanie określony, kod zostanie wdrożony w aktywnym miejscu.
profil publikowania	(Opcjonalnie) Nazwa wpisu tajnego usługi GitHub zawierającego profil publikowania.

Obsługiwane są również następujące parametry, ale są używane tylko w określonych przypadkach:

Parametr	Wyjaśnienie
Pakiet	(Opcjonalnie) Ustawia ścieżkę podrzędną w repozytorium, z którego ma być publikowane. Domyślnie ta wartość jest ustawiona na `.`wartość , co oznacza, że wszystkie pliki i foldery w repozytorium GitHub są wdrażane.
respect-pom-xml	(Opcjonalnie) 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 `false`wartość , co oznacza, że `package` parametr musi wskazywać lokalizację artefaktu aplikacji, taką jak `./target/azure-functions/`
respect-funcignore	(Opcjonalnie) 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`.
scm-do-build-during-deployment	(Opcjonalnie) Określa, czy witryna wdrażania usługi App Service (Kudu) wykonuje operacje wdrażania wstępnego. Lokacja wdrożenia aplikacji funkcji znajduje się pod adresem `https://<APP_NAME>.scm.azurewebsites.net/`. Zmień to ustawienie na `true` , gdy musisz kontrolować wdrożenia w usłudze Kudu, a nie rozpoznawać zależności w przepływie pracy funkcji GitHub Actions. Domyślna wartość to `false`. Aby uzyskać więcej informacji, zobacz ustawienie SCM_DO_BUILD_DURING_DEPLOYMENT .
enable-oryx-build	(Opcjonalnie) Czy lokacja wdrożenia Kudu rozwiązuje zależności projektu przy użyciu rozwiązania Oryx. Ustaw wartość na `true` , gdy chcesz użyć narzędzia Oryx, aby rozwiązać problemy z zależnościami projektu przy użyciu kompilacji zdalnej zamiast przepływu pracy funkcji GitHub Actions. W przypadku `true`polecenia należy również ustawić wartość `scm-do-build-during-deploymenttrue`. Domyślna wartość 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 w aplikacji funkcji przy użyciu wdrożenia zip dla usługi Azure Functions.
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