Azure Fundamentals · Lektion

GitHub Actions i Azure

Återskapa CI/CD-arbetsflödet med GitHub Actions och åtgärden azure/webapps-deploy och förstå när GitHub Actions bör väljas framför Azure Pipelines.

Lektion 4 av 413 steg

GitHub Actions i Azure är en gratis lektion i Azure Fundamentals på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Azure Fundamentals, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Azure Fundamentals innehåller totalt 4 lektioner.

Vad är GitHub Actions?

GitHub Actions är GitHubs inbyggda plattform för CI/CD och automatisering. Arbetsflöden definieras i YAML-filer som lagras i katalogen .github/workflows/ i Ert repositorium och utlöses av GitHub-händelser — pushar, pull requests, releaser med mera. GitHub Actions är djupt integrerat med GitHub-ekosystemet (ärenden, PR:er, paket och säkerhetsskanning) och erbjuder en omfattande marknadsplats med åtgärder från communityn för uppgifter som att bygga, testa och distribuera till Azure.

Strukturen för GitHub Actions-arbetsflöden

En arbetsflödesfil för GitHub Actions har tre avsnitt på toppnivå. on definierar utlösande händelser. env anger globala miljövariabler. jobs definierar ett eller flera jobb, där varje jobb körs på en runner (GitHub-hanterad eller självhostad). Varje jobb har steps — antingen run (skalskript) eller uses (en förbyggd åtgärd). Jobb körs parallellt som standard; använd needs för att skapa sekventiella beroenden.

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  NODE_VERSION: '18.x'

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    - run: npm ci
    - run: npm test

Autentisera mot Azure från GitHub Actions

Det rekommenderade sättet att autentisera GitHub Actions mot Azure är OpenID Connect (OIDC) — det utfärdar kortlivade token utan att långlivade hemligheter behöver lagras i GitHub. Konfigurera en federerad identitetsautentiseringsuppgift på en Azure App Registration eller Managed Identity och ge den förtroende för Ert GitHub-repositorium och Er gren. Använd åtgärden azure/login@v2 för att byta GitHubs OIDC-token mot en Azure-åtkomsttoken — inga klienthemligheter behöver lagras i GitHub Secrets.

# Configure OIDC federated credential in Azure
az ad app federated-credential create \
  --id <AppRegistrationObjectId> \
  --parameters '{
    "name": "github-oidc",
    "issuer": "https://token.actions.githubusercontent.com",
    "subject": "repo:myorg/myrepo:ref:refs/heads/main",
    "audiences": ["api://AzureADTokenExchange"]
  }'

# In the workflow: login via OIDC
# permissions:
#   id-token: write
#   contents: read
# - uses: azure/login@v2
#   with:
#     client-id: ${{ vars.AZURE_CLIENT_ID }}
#     tenant-id: ${{ vars.AZURE_TENANT_ID }}
#     subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

Distribuera till Azure App Service

Åtgärden azure/webapps-deploy@v3 distribuerar kod eller en containeravbildning till Azure App Service. Den hanterar slotdistribution, paketbaserad distribution och distribution av Docker-avbildningar. Kombinera den med azure/login@v2 för autentisering. Ni kan rikta distributionen mot en staging-slot, köra smoketester och sedan växla slotten med åtgärden azure/CLI@v2, som kör kommandot för slotväxling — på så sätt återskapas Azure Pipelines blågröna distributionsmönster helt i GitHub Actions.

# .github/workflows/deploy.yml
jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    steps:
    - uses: actions/checkout@v4

    - uses: azure/login@v2
      with:
        client-id: ${{ vars.AZURE_CLIENT_ID }}
        tenant-id: ${{ vars.AZURE_TENANT_ID }}
        subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

    - name: Build and zip app
      run: npm ci && npm run build && zip -r app.zip dist/

    - uses: azure/webapps-deploy@v3
      with:
        app-name: myUniqueWebApp
        slot-name: staging
        package: app.zip

Distribuera till Azure Kubernetes Service

Distribuera till AKS från GitHub Actions med åtgärden azure/k8s-deploy@v5. Den använder kubectl apply för att distribuera manifest, utför bildsubstitution (ersätter bildtaggen med taggen för den aktuella builden) och övervakar utrullningens hälsa. Åtgärden azure/aks-set-context@v4 konfigurerar kubectl-autentiseringsuppgifter genom att hämta klustrets kubeconfig med hjälp av den autentiserade Azure-sessionen.

jobs:
  deploy-aks:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    steps:
    - uses: actions/checkout@v4
    - uses: azure/login@v2
      with:
        client-id: ${{ vars.AZURE_CLIENT_ID }}
        tenant-id: ${{ vars.AZURE_TENANT_ID }}
        subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}

    - uses: azure/aks-set-context@v4
      with:
        resource-group: MyRG
        cluster-name: myAKSCluster

    - uses: azure/k8s-deploy@v5
      with:
        namespace: production
        manifests: k8s/
        images: 'mycontainerregistry.azurecr.io/myapp:${{ github.sha }}'

GitHub Secrets och variabler

Lagra känsliga värden i GitHub Secrets — krypterade värden som är tillgängliga som ${{ secrets.SECRET_NAME }} i arbetsflöden. Icke-känslig konfiguration lägger Ni i GitHub Variables — tillgänglig som ${{ vars.VARIABLE_NAME }}. Båda kan begränsas till ett repositorium, en miljö eller en organisation. Använd environments i GitHub Actions för att lägga till skyddsregler (obligatoriska granskare och distributionsgrenar) på liknande sätt som Azure DevOps Environments.

# Reference secrets and variables in a workflow
steps:
- name: Configure app settings
  uses: azure/CLI@v2
  with:
    inlineScript: |
      az webapp config appsettings set \
        --name myUniqueWebApp \
        --resource-group MyRG \
        --settings \
          DATABASE_URL='${{ secrets.DATABASE_URL }}' \
          API_VERSION='${{ vars.API_VERSION }}'

Skyddsregler för miljöer

GitHub Actions Environments (konfigureras under Settings → Environments i repositoriet) lägger till distributionsgrindar som liknar miljöerna i Azure DevOps. Ni kan kräva obligatoriska granskare som måste godkänna innan ett jobb som riktar sig mot miljön körs, begränsa distributioner till specifika grenar (endast main får distribuera till Production) och lägga till väntetimer för att fördröja distributioner. Jobb som riktar sig mot en skyddad miljö pausas tills alla skyddsregler är uppfyllda.

# Workflow job targeting a protected GitHub environment
jobs:
  deploy-production:
    runs-on: ubuntu-latest
    environment:
      name: Production           # Must have 2 approvers in GitHub settings
      url: https://myapp.contoso.com
    needs: deploy-staging
    steps:
    - uses: azure/login@v2
      with:
        client-id: ${{ vars.AZURE_CLIENT_ID }}
        tenant-id: ${{ vars.AZURE_TENANT_ID }}
        subscription-id: ${{ vars.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/webapps-deploy@v3
      with:
        app-name: myUniqueWebApp
        package: app.zip

Återanvändbara arbetsflöden och sammansatta åtgärder

Undvik att duplicera CI/CD-logik mellan repositorier genom att använda två funktioner i GitHub Actions. Med återanvändbara arbetsflöden kan Ni definiera ett arbetsflöde i ett repositorium och anropa det från arbetsflöden i andra repositorier med uses: myorg/shared-workflows/.github/workflows/deploy.yml@main. Sammansatta åtgärder samlar flera steg i en enda åtgärd som lagras i ett repositorium och kan återanvändas med uses: myorg/my-actions/deploy@v1. Båda främjar DRY-principen i organisationens CI/CD-pipelines.

# Call a reusable workflow from another workflow
jobs:
  deploy:
    uses: myorg/shared-workflows/.github/workflows/deploy-appservice.yml@main
    with:
      app-name: myUniqueWebApp
      slot-name: staging
      package-path: dist/
    secrets:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

GitHub Actions jämfört med Azure Pipelines: när ska Ni välja vad?

Välj GitHub Actions när koden finns på GitHub, teamet föredrar GitHub-gränssnittet, Ni vill ha tät integration med GitHubs PR-kontroller och kodskanning eller bygger projekt med öppen källkod (generöst antal kostnadsfria minuter). Välj Azure Pipelines när Ni behöver integration med Azure Boards, avancerad testning med Azure Test Plans, hantering av Azure Artifacts-feeds, när koden finns i Azure Repos eller när Ni behöver komplex releasehantering i flera steg med grindar över många miljöer. Båda stöder distribution till Azure lika väl.

GitHub Actions Marketplace

GitHub Actions Marketplace innehåller tusentals åtgärder från communityn och officiella åtgärder för vanliga uppgifter. Microsoft publicerar officiella Azure-åtgärder: azure/login, azure/webapps-deploy, azure/aks-set-context, azure/k8s-deploy, azure/CLI, azure/arm-deploy och många fler. Lås alltid åtgärder till en specifik versionstagg (till exempel @v3) eller ett commit-SHA för att förhindra attacker mot leveranskedjan där en komprometterad åtgärd uppdateras med skadlig kod.

# Pin actions to specific version (recommended)
- uses: actions/checkout@v4         # Pinned to v4 tag
- uses: azure/login@v2               # Pinned to v2
- uses: azure/webapps-deploy@v3      # Pinned to v3

# Extra security: pin to commit SHA
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683

# Avoid unpinned 'latest' or branch references
# - uses: some-action@main           # UNSAFE - could change at any time

Självhostade runners för privata nätverk

GitHub-hanterade runners har endast åtkomst till det offentliga internet — de kan inte nå privata Azure-resurser (SQL-databaser och interna API:er) utan att dessa resurser exponeras offentligt. Använd självhostade runners på virtuella Azure-datorer i Ert VNet för distributioner till privata resurser. Registrera en runner genom att hämta GitHub Actions-runneragenten, konfigurera den med URL:en till Ert repositorium och en registreringstoken och köra den som en tjänst. Skala självhostade runners med Azure Container Apps för elastiska runner-pooler.

# Register a self-hosted runner on an Azure VM
# 1. Download runner (run on the VM)
curl -O -L https://github.com/actions/runner/releases/download/v2.317.0/actions-runner-linux-x64-2.317.0.tar.gz
mkdir actions-runner && tar xzf ./actions-runner-linux-x64-2.317.0.tar.gz -C actions-runner
cd actions-runner

# 2. Configure (use token from GitHub Settings > Actions > Runners)
./config.sh --url https://github.com/myorg/myrepo --token <REGISTRATION_TOKEN>

# 3. Run as a service
sudo ./svc.sh install && sudo ./svc.sh start

# Use in workflow
# runs-on: self-hosted

Snabbkontroll

Testa Er förståelse av koncepten i Microsoft Azure Fundamentals (AZ-900) från den här lektionen.

Sammanfattning av lektionen

I den här lektionen lärde Ni Er att arbetsflöden i GitHub Actions är YAML-filer i .github/workflows/ som utlöses av GitHub-händelser och körs på runners, att federerade OIDC-autentiseringsuppgifter möjliggör hemlighetslös Azure-autentisering från GitHub Actions och att GitHub Environments med skyddsregler lägger till godkännandegrindar för produktionsdistributioner. Därmed är kursen i Azure DevOps slutförd — nästa avsnitt handlar om Azure Monitor och Log Analytics.

Gratis att börja

Lär dig Azure Fundamentals med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”GitHub Actions i Azure” gratis?

Ja – hela texten till ”GitHub Actions i Azure” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Azure Fundamentals, kan Ni uppgradera till CoddyKit PRO. Kursen i Azure Fundamentals innehåller totalt 4 lektioner.

Vad lär jag mig i ”GitHub Actions i Azure”?

Återskapa CI/CD-arbetsflödet med GitHub Actions och åtgärden azure/webapps-deploy och förstå när GitHub Actions bör väljas framför Azure Pipelines. Ni övar på Azure Fundamentals med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Azure Fundamentals?

Du behöver inga förkunskaper. Utbildningen i Azure Fundamentals på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”GitHub Actions i Azure”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Azure Fundamentals-lektionen?

Ja. Varje Azure Fundamentals-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Översikt över Azure DevOps Services
  2. Bygga en CI-pipeline med Azure Pipelines
  3. Kontinuerlig distribution till Azure
  4. GitHub Actions i Azure
← Tillbaka till Azure Fundamentals