Continue levering met behulp van GitHub Actions

Artikel
03/16/2024

U kunt een GitHub Actions-werkstroom gebruiken om een werkstroom te definiëren om automatisch code te bouwen en te implementeren in uw functie-app in Azure Functions.

Een YAML-bestand (.yml) dat de werkstroomconfiguratie definieert, wordt bijgehouden in het /.github/workflows/ pad in uw opslagplaats. Deze definitie bevat de acties en parameters waaruit de werkstroom bestaat, die specifiek is voor de ontwikkeltaal van uw functies. Een GitHub Actions-werkstroom voor Functions voert de volgende taken uit, ongeacht de taal:

Stel de omgeving in.
Bouw het codeproject.
Implementeer het pakket in een functie-app in Azure.

De actie Azure Functions verwerkt de implementatie naar een bestaande functie-app in Azure.

U kunt handmatig een werkstroomconfiguratiebestand voor uw implementatie maken. U kunt het bestand ook op een van de volgende manieren genereren op basis van een set taalspecifieke sjablonen:

In Azure Portal
Met behulp van de Azure CLI
Vanuit uw GitHub-opslagplaats

Als u uw YAML-bestand niet handmatig wilt maken, selecteert u een andere methode bovenaan het artikel.

Vereisten

Een Azure-account met een actief abonnement. Gratis een account maken
Een GitHub-account. Als u geen account hebt, kunt u zich registreren voor een gratis account.
Een werkende functie-app die wordt gehost in Azure met broncode in een GitHub-opslagplaats.

Azure CLI, bij het lokaal ontwikkelen. U kunt ook de Azure CLI in Azure Cloud Shell gebruiken.

Genereer implementatiereferenties

Omdat GitHub Actions uw publicatieprofiel gebruikt voor toegang tot uw functie-app tijdens de implementatie, moet u eerst uw publicatieprofiel ophalen en veilig opslaan als een GitHub-geheim.

Belangrijk

Het publicatieprofiel is een waardevolle referentie waarmee toegang tot Azure-resources mogelijk is. Zorg ervoor dat u altijd veilig vervoert en opslaat. In GitHub mag het publicatieprofiel alleen worden opgeslagen in GitHub-geheimen.

Uw publicatieprofiel downloaden

Het publicatieprofiel van uw functie-app downloaden:

Selecteer de pagina Overzicht van de functie-app en selecteer vervolgens Publicatieprofiel ophalen.
Sla de inhoud van het bestand op en kopieer deze.

Het GitHub-geheim toevoegen

Ga in GitHub naar uw opslagplaats.
Ga naar Instellingen.
Selecteer Geheimen en variabelenacties>.
Selecteer Nieuw opslagplaatsgeheim.
Voeg een nieuw geheim toe met de naam AZURE_FUNCTIONAPP_PUBLISH_PROFILE en de waarde die is ingesteld op de inhoud van het publicatieprofielbestand.
Selecteer Geheim toevoegen.

GitHub kan nu worden geverifieerd bij uw functie-app in Azure.

De werkstroom maken op basis van een sjabloon

De beste manier om handmatig een werkstroomconfiguratie te maken, is door te beginnen met de officieel ondersteunde sjabloon.

De werkstroomconfiguratie maken in de portal

Wanneer u de portal gebruikt om GitHub Actions in te schakelen, maakt Functions een werkstroombestand op basis van uw toepassingsstack en voert dit door naar uw GitHub-opslagplaats in de juiste map.

In de portal wordt uw publicatieprofiel automatisch opgehaald en toegevoegd aan de GitHub-geheimen voor uw opslagplaats.

Tijdens het maken van de functie-app

U kunt snel aan de slag met GitHub Actions via het tabblad Implementatie wanneer u een functie maakt in Azure Portal. Een GitHub Actions-werkstroom toevoegen wanneer u een nieuwe functie-app maakt:

Selecteer In Azure Portal de optie Implementatie in de stroom Functie-app maken.
Schakel continue implementatie in als u wilt dat elke code-update een codepush naar Azure Portal activeert.
Voer uw GitHub-organisatie, opslagplaats en vertakking in.
Voltooi de configuratie van uw functie-app. Uw GitHub-opslagplaats bevat nu een nieuw werkstroombestand in /.github/workflows/.

Voor een bestaande functie-app

Een GitHub Actions-werkstroom toevoegen aan een bestaande functie-app:

Navigeer naar uw functie-app in Azure Portal en selecteer Deployment Center.
Selecteer GitHub als bron. Als u het standaardbericht Building met GitHub Actions niet ziet, selecteert u Change provider choose GitHub Actions en selecteert u OK.
Als u nog geen geautoriseerde GitHub-toegang hebt, selecteert u Autoriseren. Geef uw GitHub-referenties op en selecteer Aanmelden. Als u een ander GitHub-account wilt autoriseren, selecteert u Account wijzigen en meldt u zich aan met een ander account.
Selecteer uw GitHub-organisatie, -opslagplaats en -vertakking. Als u wilt implementeren met GitHub Actions, moet u schrijftoegang hebben tot deze opslagplaats.
Kies in verificatie-instellingen of GitHub Actions moeten worden geverifieerd met een door de gebruiker toegewezen identiteit of met behulp van basisverificatiereferenties . Voor basisverificatie worden de huidige referenties gebruikt.
Selecteer Voorbeeldbestand om het werkstroombestand te zien dat wordt toegevoegd aan uw GitHub-opslagplaats in github/workflows/.
Selecteer Opslaan om het werkstroombestand toe te voegen aan uw opslagplaats.

Werkstroomconfiguratie toevoegen aan uw opslagplaats

U kunt de az functionapp deployment github-actions add opdracht gebruiken om een werkstroomconfiguratiebestand te genereren op basis van de juiste sjabloon voor uw functie-app. Het nieuwe YAML-bestand wordt vervolgens opgeslagen op de juiste locatie (/.github/workflows/) in de GitHub-opslagplaats die u opgeeft, terwijl het publicatieprofielbestand voor uw app wordt toegevoegd aan GitHub-geheimen in dezelfde opslagplaats.

Voer deze az functionapp opdracht uit, vervang de waarden githubUser/githubRepoenMyResourceGroupMyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Deze opdracht maakt gebruik van een interactieve methode om een persoonlijk toegangstoken voor uw GitHub-account op te halen.

In het terminalvenster ziet u ongeveer het volgende bericht:

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

Kopieer de unieke XXXX-XXXX code, blader naar https://github.com/login/deviceen voer de code in die u hebt gekopieerd. Nadat u uw code hebt ingevoerd, ziet u ongeveer het volgende bericht:

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

Ga naar uw GitHub-opslagplaats en selecteer Acties. Controleer of uw werkstroom is uitgevoerd.

Het configuratiebestand voor de werkstroom maken

U kunt het configuratiebestand voor de Werkstroom voor GitHub Actions maken vanuit de Azure Functions-sjablonen rechtstreeks vanuit uw GitHub-opslagplaats.

Ga in GitHub naar uw opslagplaats.
Selecteer Acties en nieuwe werkstroom.
Zoeken naar functies.
Zoek in de weergegeven werkstromen van de functions-app die zijn gemaakt door Microsoft Azure, de werkstroom die overeenkomt met uw codetaal en selecteer Configureren.
Werk in het zojuist gemaakte YAML-bestand de env.AZURE_FUNCTIONAPP_NAME parameter bij met de naam van uw functie-app-resource in Azure. Mogelijk moet u desgewenst de parameter bijwerken waarmee de taalversie wordt ingesteld die door uw app wordt gebruikt, zoals DOTNET_VERSION voor C#.
Controleer of het nieuwe werkstroombestand wordt opgeslagen en /.github/workflows/ selecteer Wijzigingen doorvoeren....

Een werkstroomconfiguratie bijwerken

Als u om een of andere reden een bestaande werkstroomconfiguratie moet bijwerken of wijzigen, navigeert u naar de /.github/workflows/ locatie in uw opslagplaats, opent u het specifieke YAML-bestand, brengt u de benodigde wijzigingen aan en voert u de updates door naar de opslagplaats.

Voorbeeld: werkstroomconfiguratiebestand

In het volgende sjabloonvoorbeeld wordt versie 1 van de functions-action en een publish profile voor verificatie gebruikt. De sjabloon is afhankelijk van de gekozen taal en het besturingssysteem waarop uw functie-app is geïmplementeerd:

Windows
Linux

Als uw functie-app wordt uitgevoerd op Linux, selecteert u Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy DotNet project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy Java project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy Java project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy Node.js project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy Node.js project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy Python project to Azure Function App

on:
  [push]

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

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

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

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

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

name: Deploy PowerShell project to Azure Function App

on:
  [push]

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

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

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

name: Deploy PowerShell project to Azure Function App

on:
  [push]

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

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

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

Azure Functions-actie

Met de actie Azure Functions (Azure/azure-functions) wordt gedefinieerd hoe uw code wordt gepubliceerd naar een bestaande functie-app in Azure of naar een specifieke site in uw app.

Parameters

De volgende parameters worden het meest gebruikt met deze actie:

Parameter	Uitleg
app-naam	(Verplicht) De naam van uw functie-app.
sitenaam	(Optioneel) De naam van een specifieke implementatiesite waarnaar u wilt implementeren. De site moet al bestaan in uw functie-app. Wanneer deze niet is opgegeven, wordt de code geïmplementeerd in de actieve site.
publicatieprofiel	(Optioneel) De naam van het GitHub-geheim dat uw publicatieprofiel bevat.

De volgende parameters worden ook ondersteund, maar worden alleen in specifieke gevallen gebruikt:

Parameter	Uitleg
package	(Optioneel) Hiermee stelt u een subpad in uw opslagplaats in waaruit u wilt publiceren. Deze waarde is standaard ingesteld op `.`, wat betekent dat alle bestanden en mappen in de GitHub-opslagplaats worden geïmplementeerd.
respect-pom-xml	(Optioneel) Alleen gebruikt voor Java-functies. Of het vereist is dat het implementatieartefact van uw app wordt afgeleid van het pom.xml-bestand. Wanneer u Java-functie-apps implementeert, moet u deze parameter `true` instellen op en instellen `package` op `.`. Deze parameter is standaard ingesteld op `false`, wat betekent dat de parameter moet verwijzen naar de `package` artefactlocatie van uw app, zoals `./target/azure-functions/`
respect-funcignore	(Optioneel) Of GitHub Actions uw .funcignore-bestand respecteert om bestanden en mappen uit te sluiten die erin zijn gedefinieerd. Stel deze waarde in op `true` wanneer uw opslagplaats een .funcignore-bestand heeft en u deze wilt gebruiken om paden en bestanden uit te sluiten, zoals configuraties van teksteditor, .vscode/of een virtuele Python-omgeving (.venv/). De standaardinstelling is `false`.
scm-do-build-during-deployment	(Optioneel) Of de App Service-implementatiesite (Kudu) predeploymentbewerkingen uitvoert. De implementatiesite voor uw functie-app vindt u op `https://<APP_NAME>.scm.azurewebsites.net/`. Wijzig deze instelling in `true` wanneer u de implementaties in Kudu moet beheren in plaats van de afhankelijkheden in de GitHub Actions-werkstroom op te lossen. De standaardwaarde is `false`. Zie de instelling SCM_DO_BUILD_DURING_DEPLOYMENT voor meer informatie.
enable-oryx-build	(Optioneel) Of de Kudu-implementatiesite uw projectafhankelijkheden oplost met behulp van Oryx. Stel in op `true` wanneer u Oryx wilt gebruiken om uw projectafhankelijkheden op te lossen met behulp van een externe build in plaats van de GitHub Actions-werkstroom. Wanneer `true`moet u ook instellen `scm-do-build-during-deployment` op `true`. De standaardwaarde is `false`.

Overwegingen

Houd rekening met de volgende overwegingen bij het gebruik van de Azure Functions-actie:

Wanneer u GitHub Actions gebruikt, wordt de code geïmplementeerd in uw functie-app met behulp van zip-implementatie voor Azure Functions.
De referenties die door GitHub zijn vereist om verbinding te maken met Azure voor implementatie, worden opgeslagen als Geheimen in uw GitHub-opslagplaats en geopend in de implementatie als secrets.<SECRET_NAME>.
De eenvoudigste manier om GitHub Actions te verifiëren met Azure Functions voor implementatie is met behulp van een publicatieprofiel. U kunt zich ook verifiëren met behulp van een service-principal. Zie deze GitHub Actions-opslagplaats voor meer informatie.
De acties voor het instellen van de omgeving en het uitvoeren van een build worden gegenereerd op basis van de sjablonen en zijn taalspecifiek.
De sjablonen gebruiken env elementen om instellingen te definiëren die uniek zijn voor uw build en implementatie.

Volgende stappen

Meer informatie over Azure- en GitHub-integratie

Share via