GitHub Actions kullanarak Azure İşlevleri'e deploy

Azure/functions-action kullanarak, işlev kodunuzu Azure’a otomatik olarak derlemek ve dağıtmak için bir GitHub Actions workflow 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.
Deponuza, OpenID Connect (OIDC) ile kimlik doğrulamak için azure/login kullanan ve ardından dağıtım yapmak için Azure/functions-action çağıran bir iş akışı YAML dosyası ekleyin.

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.

Azure İşlevleri için bir iş akışı yapılandırması oluşturun

Deponuzdaki /.github/workflows/ yolunda iş akışı yapılandırmasını tanımlayan bir YAML (.yml) dosyası bulundurursunuz. 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ğrulamasıyla ilgili dikkat edilmesi gerekenler

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.
Projenin kaynak kodu GitHub deposunda bulunuyor.
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 clientId ve tenantId değerlerini not 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, Website Contributor rolünü yönetilen kimliğe işlev uygulamanız kapsamında atayın:

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

<APP_NAME> ve <RESOURCE_GROUP> ifadelerini sırasıyla uygulamanızın ve kaynak grubunuzun adlarıyla değiştirin.

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 Yönetilen kimliğin clientId

AZURE_TENANT_ID Yönetilen kimliğin tenantId

AZURE_SUBSCRIPTION_ID Fonksiyon uygulamanızı içeren abonelik kimliği

Name	Değer
`AZURE_CLIENT_ID`	Yönetilen kimliğin `clientId`
`AZURE_TENANT_ID`	Yönetilen kimliğin `tenantId`
`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. GitHub Actions ile Azure Container Apps'e dağıtma. 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 AZURE_FUNCTIONAPP_NAME gerektirir. 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ı. pom.xml içinde `functionAppName` ile eşleşmelidir.
`JAVA_VERSION`	Yes	Projenizin Java versiyonu (örneğin, `21`)
`POM_XML_DIRECTORY`	No	pom.xmliçeren dizine giden yol. Varsayılan: `.` (depo kök dizini)

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 dizini)

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 dizini)

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 . secrets.AZURE_CLIENT_ID, secrets.AZURE_TENANT_ID ve secrets.AZURE_SUBSCRIPTION_ID referanslarının, oluşturduğunuz depo gizli anahtarlarıyla eşleştiğini doğrulayın.
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 işlev uygulamanız üzerinde bu kimliğe Web Sitesi Katkıda Bulunan 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 İş akışı ekle 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:
- Azure/functions-action öğesinden publish-profile, scm-do-build-during-deployment ve enable-oryx-build parametrelerini kaldırın.
- Varsa, environment ayarını iş tanımından kaldırın; çünkü federe kimlik bilgisi öznesi, dal tetikleyicisiyle eşleşmelidir.
- Azure/functions-action adımından önce bir azure/login 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, Azure/functions-action tarafından desteklenen giriş parametrelerini açıklar:

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 planındaki bir uygulamaya dağıtım yaptığınızda uzak derleme istemek için `true` olarak ayarlayın. Uzaktan çalışma her zaman Oryx kullanır. Ayrıca scm-do-build-during-deployment veya enable-oryx-build ayarlarını yapmayı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 derlemesi için `true` olarak ayarlayın. 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 öğesini, iş akışı yerine Oryx kullanmak için `true` olarak ayarlayın. Varsayılan: `false`. Yalnızca Linux.
yuva adı	Dağıtım yapılacak dağıtım yuvası. Varsayılan: üretim slotu.
profili-yayımla	GitHub sırının yayımlama profilinizi içeren adı. Önerilen OIDC doğrulaması kullanılırken gerek yok.
sku	Flex Consumption planında publish-profile ile kimlik doğrulaması yapılırken `flexconsumption` olarak ayarlanır. OIDC kimlik doğrulama veya diğer barındırma planlarında gerekli değil.
respect-pom-xml	(Yalnızca Java) Dağıtım artefaktını pom.xml'den türetmek için `true` olarak ayarlayın. `true` olduğunda, package değerini `.` olarak ayarlayın. Varsayılan: `false`.
respect-funcignore	.funcignore dosyanızı dikkate alıp listelenen yolları hariç tutmak için `true` olarak ayarlayın. 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
profili yayımla	Önerilmez	Önerilmez	Önerilmez	Önerilmez
sku	Yalnızca profili yayımla	—	—	—
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	Paket dağıtımı
Elastik Premium	ZIP dağıtımı
Özel (App Service)	ZIP dağıtımı
Tüketim	Windows: ZIP 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-09-16