GitHub Actions kullanarak Azure İşlevleri'e deploy

Fonksiyon kodunuzu otomatik olarak Azure'a Azure/functions-action kullanabilirsiniz.

GitHub Actions kullanarak dağıtmak için şu üç temel adımı tamamlayın:

Azure'da GitHub deponuza güvenen federe bir kimlik sertifikası ile kullanıcı tarafından atanan bir kimlik oluşturun ve fonksiyon uygulamanızda Web Sitesi Katkı Sağlayıcı rolünü atayın.
GitHub'ta kimliğin istemci kimliği, kiracı kimliği ve abonelik kimliğini depo sırları olarak ekleyin.
OpenID Connect (OIDC) ile kimlik doğrulama için kullanan bir iş akışı YAML dosyası azure/login deponuza ekleyin, ardından dağıtımı çağırın Azure/functions-action .

Azure portalını kullanarak GitHub Actions'ı etkinleştirdiğinizde, Functions bu görevleri hem Azure aboneliğinizde hem de GitHub depoda otomatik olarak gerçekleştirir.

Create a workflow configuration for Azure İşlevleri

Depodaki yolda iş akışı yapılandırmasını /.github/workflows/ tanımlayan bir YAML dosyası (.yml) tutarsınız. Bu tanım, işlevlerinizin geliştirme diline özgü olan iş akışını oluşturan eylemleri ve parametreleri içerir.

Makalenin üstündeki seçici kullanarak iş akışı dosyanızı oluşturmak için bir yöntem seçin:

Method	En iyi kullanım alanları	OIDC desteği
İş akışı şablonu	Tam kontrol: OIDC'ye hazır bir şablonu kopyala ve özelleştir	Yapılandırma gerektirir
Azure portalı	En kolay kurulum: portal sizin için kimlik, kimlik bilgileri ve iş akışı dosyasını oluşturabilir	Senin için yapılandırıldı
GitHub pazar yeri	GitHub önceliğinde: GitHub'un yerleşik pazar yeri şablonlarından başla	Yapılandırma ve şablon değişikliği gerektirir

Kimlik doğrulamasına genel bakış

GitHub Actions, kodunuzu dağıtmak için Azure ile kimlik doğrulaması yapmalıdır. Bu makale, önerilen kimlik doğrulama yöntemi olan OpenID Connect (OIDC) kullanır. OIDC, GitHub deponuzla Microsoft Entra'da kullanıcı tarafından atanan yönetilen kimlik arasında bir güven ilişkisi oluşturmak için federasyon kimlik bilgilerini kullanır. GitHub'ta hiçbir sır saklanmaz.

OIDC kimlik doğrulama örneği

Aşağıdaki satır içi örnek, tüm iş akışı şablonlarında kullanılan temel OIDC kimlik doğrulama ve dağıtım desenini göstermektedir:

permissions:
  id-token: write
  contents: read

steps:
  - name: 'Login via OIDC'
    uses: azure/login@v3
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

  - name: 'Deploy to Azure Functions'
    uses: Azure/functions-action@v1
    with:
      app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
      package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}

GitHub Actions OIDC kimlik doğrulama konuları

OIDC, iş yükü kimlik federasyonu kullanır ve yalnızca kullanıcı tarafından atanan yönetilen kimlikleri destekler.
Azure portalında GitHub Actions tabanlı bir dağıtımı etkinleştirdiğinizde, varsayılan olarak OIDC kimlik doğrulaması kullanılır.
OIDC ile yönetilen kimliğin istemci kimliği, kiracı kimliği ve abonelik kimliği GitHub depo sırları olarak saklanır.
Erişimi yalnızca dağıtımınız için gereken Azure kaynaklarına sınırlamak amacıyla Azure rol tabanlı erişim kontrolü (Azure RBAC) kullanın.

Önkoşullar

Etkin aboneliği olan bir Azure hesabı. Ücretsiz bir hesap oluşturun.
GitHub hesabı. Hesabınız yoksa ücretsiz olarak kaydolun.
Project kaynak kodu bir GitHub deposunda bulun.
GitHub Actions iş akışlarının temel bir anlayışı. Eğer GitHub Actions'a yeniyseniz, Understanding GitHub Actions'a bakınız.
Azure'da barındırılan çalışan bir fonksiyon uygulaması (yalnızca kod veya konteyner tabanlı).
(Sadece konteyner dağıtımı) Mevcut bir konteyner registri, örneğin Azure Container Registry.

Yerel geliştirme sırasında Azure CLI'yı kullanırken. Azure Cloud Shell'da da Azure CLI kullanabilirsiniz.

GitHub Actions dağıtımı için yönetilen bir kimlik oluşturun

OpenID Connect (OIDC), GitHub Actions'ın Azure İşlevleri'a dağıtımları için önerilen kimlik doğrulama yöntemidir. OIDC ile, Azure'da kullanıcı tarafından atanan bir yönetilen kimlik yapılandırır ve GitHub deponuzla bir güven ilişkisi oluşturursunuz. İş akışı, kimlik bilgilerini sır olarak saklamadan Azure ile kimlik doğrulaması yapabilir.

Kullanıcı tarafından atanan yönetilen kimlik oluşturmak için az identity create komutunu kullanın:
```
az identity create --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> \
--query "{clientId: clientId, tenantId: tenantId}" -o table
```
<RESOURCE_GROUP> ifadesini kaynak grubunuzun adıyla değiştirin.
Çıktıdan ve clientId değerlerini not tenantId edin. Ayrıca abonelik kimliğinizi alın:
```
az account show --query "{subId: id}" -o table
```
Bu üç değeri daha sonra GitHub'a kimlik bilgileri eklediğinizde ihtiyacınız olacak.

Az role assignment create komutunu kullanarak rolü Website Contributor yönetilen kimliğe atamak için fonksiyon uygulamanıza göre kapsamlı:

IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
FUNCTION_APP_ID=$(az functionapp show --name <APP_NAME> --resource-group <RESOURCE_GROUP> --query 'id' -o tsv)
az role assignment create --assignee $IDENTITY_PRINCIPAL --role "Website Contributor" --scope $FUNCTION_APP_ID

Ve <APP_NAME><RESOURCE_GROUP> yerine uygulamasını ve kaynak grubunun isimlerini sırasıyla ekleyin.

Az identity federated-credential create komutunu kullanarak GitHub deponuzdan tokenlara güvenen bir federated credential oluşturabilirsiniz:

az identity federated-credential create \
    --identity-name myGitHubDeployIdentity \
    --resource-group <RESOURCE_GROUP> \
    --name github-deploy-credential \
    --issuer https://token.actions.githubusercontent.com \
    --subject repo:<GITHUB_ORG>/<REPO_NAME>:ref:refs/heads/<BRANCH_NAME> \
    --audiences api://AzureADTokenExchange

<RESOURCE_GROUP>, <GITHUB_ORG>, <REPO_NAME> ve <BRANCH_NAME> değerlerini kendi değerlerinizle değiştirin. Konu, iş akışınızı tetikleyen dalla eşleşmeli.

(İsteğe bağlı) Azure Container Registry'den bir konteyner dağıtıyorsanız, rolü acrpull yönetilen kimliğe de atayın:

IDENTITY_PRINCIPAL=$(az identity show --name myGitHubDeployIdentity --resource-group <RESOURCE_GROUP> --query 'principalId' -o tsv)
az role assignment create --assignee $IDENTITY_PRINCIPAL --role acrpull \
    --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP>/providers/Microsoft.ContainerRegistry/registries/<REGISTRY_NAME>

<SUBSCRIPTION_ID>, <RESOURCE_GROUP> ve <REGISTRY_NAME> değerlerini kendi değerlerinizle değiştirin.

GitHub'a kimlik bilgileri ekle

Yönetilen kimliği oluştururken kopyaladığınız değerleri kullanın.

GitHub içinde deponuza gidin.
Ayarlar>Sırları ve Değişkenler>Eylemleri'ne gidin.
Secrets sekmesinde Yeni depo sırrı seçeneğini seçin.

Aşağıdaki sırların her birini oluşturun:

Name	Değer
`AZURE_CLIENT_ID`	`clientId` Yönetilen kimlik
`AZURE_TENANT_ID`	`tenantId` Yönetilen kimlik
`AZURE_SUBSCRIPTION_ID`	Fonksiyon uygulamanızı içeren abonelik kimliği

Özel bir kayıt defterinden konteyner dağıtımları için ayrıca kayıt defterine özgü sırlara da ihtiyacınız var. Daha fazla bilgi için Docker Giriş Eylemi'ne bakınız.

Şablondan iş akışı oluşturma

El ile iş akışı yapılandırması oluşturmanın en iyi yolu resmi olarak desteklenen şablondan başlamaktır.

Doğru işletim sistemi şablonunu aldığınızdan emin olmak için Windows veya Linux seçin.
- Windows
- Linux
Windows dağıtımları runs-on: windows-latest kullanır. Konteynerize dağıtımlar Linux gerektirir.

Linux'a yapılan dağıtımlarda kullanılır runs-on: ubuntu-latest. Konteynerli dağıtımlar için Linux kullanın.

Azure İşlevleri actions deposundan dile özgü OIDC iş akışı şablonunu kullanın. Dosya içeriğini depoda adlandırılmış .github/workflows/deploy-function-app.yml yeni bir dosyaya kopyalayın:

name: Build and deploy .NET project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
  BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Perform additional steps such as running tests, if needed

      - name: 'Build and prepare .NET project for deployment'
        run: dotnet publish --configuration Release --output ./output

      - name: Upload artifact for the deployment job
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
          include-hidden-files: true  # Required for .NET projects
  
  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy .NET project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'         # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  DOTNET_VERSION: '10.0.x'                   # Set this to the .NET version of your project
  BUILD_ARTIFACT_NAME: 'released-package'    # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up .NET version: ${{ env.DOTNET_VERSION }}'
        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Perform additional steps such as running tests, if needed

      - name: 'Build and prepare .NET project for deployment'
        run: dotnet publish --configuration Release --output ./output

      - name: Upload artifact for the deployment job
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/output
          include-hidden-files: true  # Required for .NET projects
  
  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Java project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'          # set this to your function app name on Azure. Ensure that `functionAppName` in your pom.xml file matches. 
  POM_XML_DIRECTORY: '.'                      # set this to the directory which contains the pom.xml file. The deploy action will package the contents of this path.
  JAVA_VERSION: '21'                          # set this to the Java version of your project
  BUILD_ARTIFACT_NAME: 'released-package'     # Set this according to your team's naming convention

jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
        id-token: write  # Required to fetch an OIDC token to authenticate with the job
        contents: read # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.POM_XML_DIRECTORY }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Java version: ${{ env.JAVA_VERSION }}'
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'microsoft'

      - name: 'Build project with Maven'
        run: mvn clean package -DfunctionAppName=${{ env.AZURE_FUNCTIONAPP_NAME }}

      # Perform additional steps such as running tests, if needed
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.AZURE_FUNCTIONAPP_NAME }}

  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required to fetch an OIDC token to authenticate with the job
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
      
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
          respect-pom-xml: false # Set to `true` if the build artifact path is ${{ env.POM_XML_DIRECTORY }}

name: Build and deploy Java project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'          # set this to your function app name on Azure. Ensure that `functionAppName` in your pom.xml file matches. 
  POM_XML_DIRECTORY: '.'                      # set this to the directory which contains the pom.xml file. The deploy action will package the contents of this path.
  JAVA_VERSION: '21'                          # set this to the Java version of your project
  BUILD_ARTIFACT_NAME: 'released-package'     # Set this according to your team's naming convention

jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
        id-token: write  # Required to fetch an OIDC token to authenticate with the job
        contents: read # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.POM_XML_DIRECTORY }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Java version: ${{ env.JAVA_VERSION }}'
        uses: actions/setup-java@v4
        with:
          java-version: ${{ env.JAVA_VERSION }}
          distribution: 'microsoft'

      - name: 'Build project with Maven'
        run: mvn clean package -DfunctionAppName=${{ env.AZURE_FUNCTIONAPP_NAME }}

      # Perform additional steps such as running tests, if needed
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.AZURE_FUNCTIONAPP_NAME }}

  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required to fetch an OIDC token to authenticate with the job
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
      
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.POM_XML_DIRECTORY }}/downloaded-artifact'
          respect-pom-xml: false # Set to `true` if the build artifact path is ${{ env.POM_XML_DIRECTORY }}

name: Build and deploy Node.js project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  NODE_VERSION: '22'                        # Set this to the Node version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Node version: ${{ env.NODE_VERSION }}'
        uses: actions/setup-node@v6
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: 'Install project dependencies'
        run: npm install # Use `npm ci` if you have a package-lock.json file and want to ensure a clean install
      
      - name: 'Build project'
        run: npm run build --if-present
      
      - name: 'Run tests'
        run: npm run test --if-present
      
      - name: 'Prune development dependencies'
        run: npm prune --production
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: windows-latest # Assumes your target function app is Windows-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Node.js project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  NODE_VERSION: '22'                        # Set this to the Node version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Node version: ${{ env.NODE_VERSION }}'
        uses: actions/setup-node@v6
        with:
          node-version: ${{ env.NODE_VERSION }}

      - name: 'Install project dependencies'
        run: npm install # Use `npm ci` if you have a package-lock.json file and want to ensure a clean install
      
      - name: 'Build project'
        run: npm run build --if-present
      
      - name: 'Run tests'
        run: npm run test --if-present
      
      - name: 'Prune development dependencies'
        run: npm prune --production
      
      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: ubuntu-latest # Assumes your target function app is Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Build and deploy Python project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'        # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'       # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  PYTHON_VERSION: '3.13.x'                  # Set this to the Python version of your project
  BUILD_ARTIFACT_NAME: 'released-package'   # Set this according to your team's naming convention
  
jobs:
  build:
    runs-on: ubuntu-latest # Python function apps are Linux-based
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    defaults:
      run:
        shell: bash
        working-directory: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      - name: 'Set up Python version: ${{ env.PYTHON_VERSION }}'
        uses: actions/setup-python@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: 'Install project dependencies'
        run: pip install -r requirements.txt --target ".python_packages/lib/site-packages"  # Ensure requirements.txt contains all dependencies
      
      # Perform additional steps such as running tests, if needed

      - name: 'Upload artifact for the deployment job'
        uses: actions/upload-artifact@v7
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}
  
  deploy:
    runs-on: ubuntu-latest # Python function apps are Linux-based
    needs: build
    permissions:
      id-token: write  # Required for OIDC
    steps:
      - name: 'Download artifact from build job'
        uses: actions/download-artifact@v8
        with:
          name: ${{ env.BUILD_ARTIFACT_NAME }}
          path: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: '${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}/downloaded-artifact'

name: Deploy PowerShell project to Azure Function App using OIDC

on:
  push:
    branches: [ main ]
  workflow_dispatch:

env:
  AZURE_FUNCTIONAPP_NAME: 'APP_NAME'       # Set this to your function app name on Azure 
  AZURE_FUNCTIONAPP_PROJECT_PATH: '.'        # Set this to the path to your function app project, defaults to the repository root. The deploy action will package the contents of this path.
  
jobs:
  # PowerShell projects do not require a build step
  deploy:
    runs-on: windows-latest # For PowerShell projects, the OS of the runner does not affect deployment. You may use either ubuntu-latest or windows-latest.
    permissions:
      id-token: write  # Required for OIDC
      contents: read   # Required for actions/checkout
    steps:
      - name: 'Checkout repository'
        uses: actions/checkout@v6

      # Perform additional steps such as running tests, if needed
     
      - name: 'Log in to Azure with AZ CLI'
        uses: azure/login@v3
        with:
          client-id: ${{ vars.AZURE_CLIENT_ID }}
          tenant-id: ${{ vars.AZURE_TENANT_ID }}
          subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
        
      - name: 'Run the Azure Functions action'
        uses: Azure/functions-action@v1
        id: deploy-to-function-app
        with:
          app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
          package: ${{ env.AZURE_FUNCTIONAPP_PROJECT_PATH }}

# Action Requires
# 1. Setup the AZURE_CREDENTIALS secrets in your GitHub Repository
name: Linux_Container_Workflow

on:
  push:
    branches:
    - master

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

    - name: 'Login via Azure CLI'
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: 'Docker Login'
      uses: azure/docker-login@v1
      with:
        login-server: contoso.azurecr.io
        username: ${{ secrets.REGISTRY_USERNAME }}
        password: ${{ secrets.REGISTRY_PASSWORD }}

    - name: 'Compose Customized Docker Image'
      shell: bash
      run: |
        # If your function app project is not located in your repository's root
        # Please change the path to your directory for docker build
        docker build . -t REGISTRY/NAMESPACE/IMAGE:TAG
        docker push REGISTRY/NAMESPACE/IMAGE:TAG

    - name: 'Run Azure Functions Container Action'
      uses: Azure/functions-container-action@v1
      id: fa
      with:
        app-name: PLEASE_REPLACE_THIS_WITH_YOUR_FUNCTION_APP_NAME
        image: REGISTRY/NAMESPACE/IMAGE:TAG

    #- name: 'use the published functionapp url in upcoming steps'
    #  run: |
    #    echo "${{ steps.fa.outputs.app-url }}"

    - name: Azure logout
      run: |
        az logout

Önemli

Yeni konteyner tabanlı fonksiyon uygulama dağıtımları için, native Azure Container Apps hosting modelini kullanın. Bkz. Deploy to Azure Container Apps with GitHub Actions. Burada gösterilen, Azure/functions-container-action konteyner görüntülerini Azure'daki mevcut fonksiyon uygulama kaynaklarına dağıtıyor.

Bu YAML dosyasını kullanmadan önce aşağıdaki adımları tamamlayın:

Konteyner kayıt defterinize göre , REGISTRY, NAMESPACE, ve IMAGE değerlerini TAGgüncelleyin.
Eylemde konteyner deposu kimlik bilgilerini docker/login-action güncelleyin.

Şablonda, projeniz için değişkenleri env: güncelleyin. Her şablon için .AZURE_FUNCTIONAPP_NAME Diğer değişkenler dilinize bağlıdır:

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulaması adınız
`DOTNET_VERSION`	Yes	Projenizin .NET versiyonu (örneğin, `10.0.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Proje klasörünüze giden yol. Varsayılan: `.` (depo kök)

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulamasının adı. Bir pom.xmliçinde eşleşmeli `functionAppName` .
`JAVA_VERSION`	Yes	Projenizin Java versiyonu (örneğin, `21`)
`POM_XML_DIRECTORY`	No	pom.xmliçeren dizine giden yol. Varsayılan: `.` (depo kök)

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulaması adınız
`NODE_VERSION`	Yes	Projenizin Node.js versiyonu (örneğin, `22`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Proje klasörünüze giden yol. Varsayılan: `.` (depo kök)

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulaması adınız
`PYTHON_VERSION`	Yes	Projenizin Python versiyonu (örneğin, `3.13.x`)
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Proje klasörünüze giden yol. Varsayılan: `.` (depo kök)

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulaması adınız
`AZURE_FUNCTIONAPP_PROJECT_PATH`	No	Proje klasörünüze giden yol. Varsayılan: `.` (depo kök)

Değişken	Gerekli	Description
`AZURE_FUNCTIONAPP_NAME`	Yes	Azure'daki fonksiyon uygulaması adınız
`REGISTRY`	Yes	Konteyner kayıt giriş sunucunuzu (örneğin, `contoso.azurecr.io`)
`NAMESPACE`	Yes	Kayıt defterinizdeki isim alanı/deposu
`IMAGE`	Yes	Konteyner imajı adı
`TAG`	Yes	Resim etiketi (örneğin, `${{ github.sha }}`)

OIDC şablonlarında zaten OIDC kimlik doğrulama adımı bulunuyor azure/login . Oluşturduğunuz depo secrets.AZURE_CLIENT_IDsecrets.AZURE_TENANT_ID , secrets.AZURE_SUBSCRIPTION_ID, ve referansların eşleşip eşleşmediğinden emin olun.
Bu yeni YAML dosyasını deponuzdaki /.github/workflows/ yola ekleyin.

Portalda iş akışı yapılandırmasını oluşturma

Portalı kullanarak GitHub Actions'ı etkinleştirdiğinizde, tüm kurulumu otomatik olarak Functions halleder. Yönetilen bir kimlik oluşturmanıza, kimlik bilgilerini yapılandırmanıza veya iş akışı dosyası yazmanıza gerek yok. Functions sizin için şu görevleri yerine getirir:

Azure aboneliğinizde:

Kullanıcı tarafından atanan yönetilen bir kimlik oluşturur ve fonksiyon uygulamanızda Web Sitesi Katkı Sağlayıcısı rolünü atar.
GitHub OIDC kimlik doğrulaması için yönetilen kimliğe federe bir kimlik kartı ekler.

GitHub deponuzda:

İstemci ID, abonelik ID'si ve kiracı ID değerlerini GitHub Actions sırları olarak ekler.
Uygulama yığınınıza göre bir iş akışı dosyası oluşturur ve bunu 'ye .github/workflowsbağlayır.

İşlev uygulaması oluşturma sırasında

Azure portalında bir işlev oluşturduğunuzda Dağıtım sekmesinden GitHub Actions kullanmaya hızlı bir şekilde başlayabilirsiniz. Yeni bir işlev uygulaması oluştururken GitHub Actions iş akışı eklemek için:

Azure portalında İşlev Uygulaması Oluştur akışında Deployment öğesini seçin.
Her kod güncelleştirmesinin Azure portala bir kod göndermeyi tetiklemesini istiyorsanız Continuous Deployment etkinleştirin.
GitHub ayarlarından, GitHub hesabınızı bağlamak için Authorize seçeneğini seçin. Deponuza yazma erişimi olan GitHub hesabıyla giriş yapın.
GitHub kuruluşunuzu, deponuzu ve dalınızı girin.
Isteğe bağlı olarak, iş akışı dosyasının oluşturulup depoya eklenmeden önce nasıl göründüğünü görmek için Önizleme dosyasını seçin.
İşlev uygulamanızı yapılandırmayı tamamlayın. GitHub deponuz artık /.github/workflows/'da yeni bir iş akışı dosyası içeriyor.

Mevcut bir işlev uygulaması için

Var olan bir işlev uygulamasına GitHub Actions iş akışı eklemek için:

Azure portalında fonksiyon uygulamanıza gidin ve Dağıtım>Dağıtım Merkezi'ni seçin.
Sürekli Dağıtım (CI/CD) seçeneğini seçin. Kaynak olarak GitHub'ı seçin. Eğer varsayılan Building with GitHub Actions mesajını görmüyorsanız, Change Provider'ı, GitHub Actions'ı seçin ve OK seçin.
Eğer GitHub erişimini henüz yetkilendirmediyseniz, Authorize seçeneğini seçin. GitHub kimlik bilgilerinizi sağlayın ve Sign in öğesini seçin. Farklı bir GitHub hesabını yetkilendirmek için Change Account öğesini seçin ve başka bir hesapla oturum açın.
GitHub Organization, Repository ve Branch seçin. GitHub Actions kullanarak dağıtmak için bu depoya yazma erişimine sahip olmanız gerekir.
İş Akışı seçeneği için Add a workflow seçeneğini seçin. Bu seçenek, içinde /.github/workflows/yeni bir iş akışı dosyası oluşturur. Mevcut bir iş akışını kullanmak için, Mevcut iş akışını kullan seçeneğini seçin ve iş akışı dosyanızı seçin.
Kimlik doğrulama ayarlarında, OpenID Connect (OIDC) kullanmak için Kullanıcı tarafından atanan kimlik seçeneğini seçin; bu önerilmektedir çünkü GitHub'ta sır saklamanızı gerektirmez. Aboneliğinizi ve (Yeni) önerilen kimlik adını seçin. Yeni bir kullanıcı tarafından atanan yönetilen kimlik oluşturulur ve Web Sitesi Katkıcısı rolüne erişim verilir. Mevcut bir kimlik kullanıyorsanız, önce ona Web Sitesi Katkıcı rolüne erişim vermelisiniz.

Önemli

Temel kimlik doğrulama seçtiğinizde, paylaşılan sırlar içeren yayınlama profiliniz GitHub Sırları'nda saklanır. Ayrıca SCM temel kimlik doğrulamasını etkinleştirmelisiniz, bu da uygulamanızı daha az güvenli hale getirir.
'da GitHub deponuza eklenen iş akışı dosyasını görmek için .github/workflows/ öğesini seçin.
İş akışı dosyasını deponuza eklemek için Kaydet'i seçin. Mevcut ve önceki dağıtımların durumunu görmek için Logs sekmesini seçin.

İş akışı yapılandırma dosyasını oluşturma

GitHub Actions iş akışı yapılandırma dosyasını doğrudan GitHub deponuzdan Azure İşlevleri şablonlarından oluşturabilirsiniz.

GitHub içinde deponuza gidin.
Eylemler ve Yeni iş akışı'ı seçin.
İşlevleri arayın.
Microsoft Azure tarafından yazılan görüntülenen işlevler uygulaması iş akışlarında kod dilinizle eşleşeni bulun ve Configure öğesini seçin.
Yeni oluşturulan YAML dosyasında env.AZURE_FUNCTIONAPP_NAME parametresini Azure işlev uygulaması kaynağınızın adıyla güncelleştirin. Ayrıca, uygulamanızın kullandığı dil sürümünü belirleyen parametreyi güncellemeniz gerekebilir, örneğin DOTNET_VERSION C# veya PYTHON_VERSION Python uygulamaları için.
Varsayılan şablonlar, önerilen OIDC yerine yayınlama profili doğrulaması kullanabilir. OIDC'ye geçmek ve portal davranışlarıyla uyumlu hale getirmek için aşağıdaki değişiklikleri yapın:
- publish-profile scm-do-build-during-deployment, , ve enable-oryx-build parametreleri çıkarın.Azure/functions-action
- Eğer varsa, bu environment ayarı işten kaldırın, çünkü federasyon kimlik kaynağı branch tetikleyiciyle eşleşmelidir.
- Adımdan azure/login önce bir Azure/functions-action adım ekleyin:
```
- name: 'Login via OIDC'
  uses: azure/login@v3
  with:
    client-id: ${{ secrets.AZURE_CLIENT_ID }}
    tenant-id: ${{ secrets.AZURE_TENANT_ID }}
    subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

- name: 'Run Azure Functions Action'
  uses: Azure/functions-action@v1
  with:
    app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
    package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
```
- Aşağıdaki izinleri işe ekleyin:
```
permissions:
  id-token: write
  contents: read
```
Yeni iş akışı dosyasının uygun bir isimle kaydedildiğini doğrulayın /.github/workflows/ ve Değişiklikleri Kabul et'i seçin.

Azure İşlevleri eylemi

Azure İşlevleri eylemi (Azure/functions-action), kodunuzun Azure'daki mevcut bir işlev uygulamasında veya uygulamanızdaki belirli bir yuvada nasıl yayımlandığını tanımlar.

Parametreler

Aşağıdaki tablo, aşağıdaki giriş parametrelerini açıklar:Azure/functions-action

Parametre	Description
uygulama adı	(Zorunlu) Azure'daki fonksiyon uygulamanızın adı.
paket	(Zorunlu) Projenizin yayımlanmasına giden yol. Varsayılan: `.` (depodaki tüm dosyalar).
Uzaktan Yapı	Flex Consumption uygulamasına dağıtırken Kudu'dan bir build eylemini etkinleştirmek için ayarlandı `true` . Oryx yapısı her zaman yapılır; Ayrıca scm-do-build-during deployment veya enable-oryx-build ayarlarını da ayarlamayın. Varsayılan: `false`.
scm-do-build-during-deployment	Kudu sitesinin uzaktan derlemeler gibi ön dağıtım işlemlerini gerçekleştirmesine izin verin. Dağıtım sırasında Kudu'nun projenizi oluşturmasını sağlayacak `true` . Varsayılan: `false`. Daha fazla bilgi için bkz. `SCM_DO_BUILD_DURING_DEPLOYMENT`.
enable-oryx-build	Kudu'nun Oryx kullanarak proje bağımlılıklarını çözmesine izin verin. Hem bunu hem de scm-do-build-during-deployment`true` olarak iş akışı yerine Oryx kullanacak şekilde ayarlayın. Varsayılan: `false`. Yalnızca Linux.
yuva adı	Konuşlandırılacak yerleştirme yuvası . Varsayılan: üretim slotu.
publish-profile	GitHub sırının yayımlama profilinizi içeren adı. Önerilen OIDC doğrulaması kullanılırken gerek yok.
Sku	Flex Tüketim planında `flexconsumption` ile kimlik doğrulama yaparken ayarlandı. OIDC kimlik doğrulama veya diğer barındırma planlarında gerekli değil.
respect-pom-xml	(Sadece Java) Dağıtım artefaktını pom.xml'dan türetmek için ayarlandı`true`. Ne zaman `true`, paketi olarak ayarlayın`.`. Varsayılan: `false`.
respect-funcignore	.funcignore dosyanızı onurlandırmak ve listelenen yolları dışlamak için ayarlayın `true` . Varsayılan: `false`.

Aşağıdaki tablo, her barındırma planı için hangi parametrelerin desteklendiğini göstermektedir:

Parametre	Flex Consumption	Elastik Premium	Dedicated	Consumption
uygulama adı	Gerekli	Gerekli	Gerekli	Gerekli
paket	Gerekli	Gerekli	Gerekli	Gerekli
Uzaktan Yapı	Optional	—	—	—
scm-do-build-during-deployment	—	Optional	Optional	Optional
enable-oryx-build	—	Opsiyonel (Linux)	Opsiyonel (Linux)	Opsiyonel (Linux)
yuva adı	Desteklenmiyor	Optional	Optional	Optional
publish-profile	Önerilmez	Önerilmez	Önerilmez	Önerilmez
Sku	Sadece profil yayın	—	—	—
respect-pom-xml	Isteğe bağlı (Java)	Isteğe bağlı (Java)	Isteğe bağlı (Java)	Isteğe bağlı (Java)
respect-funcignore	Optional	Optional	Optional	Optional

Dağıtım yöntemleri

GitHub Actions'ı kullandığınızda, dağıtım yöntemi barındırma planınıza bağlıdır:

Barındırma planı	Dağıtım yöntemi
Esnek Tüketim	Tek dağıtım
Elastik Premium	Zip dağıtımı
Özel (App Service)	Zip dağıtımı
Tüketim	Windows: ZIP ile dağıtım Linux: dış paket URL'si^*

* Uygulamalarınızı Linux'ta tüketim planında çalıştırma özelliği kullanımdan kaldırılması planlanıyor. Daha fazla bilgi için Azure İşlevleri Tüketim Planı Barındırma'ya bakın.

Daha fazla bilgi için bkz. deployment technologies in Azure İşlevleri.

Sonraki adımlar

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-08-14