Övning – Distribuera ARM-mallar som en del av dina CI/CD-insatser med GitHub Actions

10 minuter

Här distribuerar du en ARM-mall (Azure Resource Manager) från ett GitHub Actions-arbetsflöde.

Viktig

Du utför den här övningen utanför Microsoft Learn-miljön. Den här övningen kräver att du har en egen Azure-prenumeration, och du kan debiteras. Detta krävs eftersom du måste skapa ett huvudnamn för tjänsten, vilket är inte stöds i sandbox-prenumerationen. Om du inte redan har en Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Skapa ditt GitHub-konto och din lagringsplats

Om du inte har något GitHub-konto skapar du ett nu på sidan skapande av GitHub-konto. (Det är gratis.)

Skärmbild som visar sidan för att skapa GitHub-kontot.

När du har ett konto loggar du in och skapar en ny lagringsplats där du kan behålla dina mallar som en del av IaC-modellen (infrastruktur som kod). Så här skapar du lagringsplatsen (kallas ofta för en lagringsplats i branschen):

I det övre högra hörnet på en sida på GitHub-webbplatsen använder du listrutan + och väljer Ny lagringsplats. Eller välj den gröna knappen Skapa lagringsplats om den finns där.
Ange ett kort, minnesvärt namn för lagringsplatsen. Använd till exempel Deploy-ARM-Template. Du kan också lägga till en beskrivning av lagringsplatsen. Använd till exempel Distribuera min första ARM-mall med GitHub Actions.
Välj en inställning för lagringsplatssynlighet. Offentliga lagringsplatser är tillgängliga för alla på Internet. Privata lagringsplatser är endast tillgängliga för dig och för personer som du uttryckligen delar åtkomst med. Båda fungerar med den här övningen.
Under Initiera det här lagringsutrymmet med: välj Lägg till en README-fil.
Välj Skapa lagringsplats.

Du skapade lagringsplatsen och initierade den med en README-fil. Det är dags att kommitta en mall och en mallparameterfil till repot.

Not

README-filer är ett bra ställe för att beskriva projektet mer detaljerat, eller för att lägga till viss dokumentation, till exempel hur du installerar eller använder projektet. Innehållet i README-filen visas automatiskt på framsidan av lagringsplatsen.

Lägg till en ARM-mallfil i arkivet

På GitHub går du till huvudsidan för lagringsplatsen.
Ovanför fillistan, i listrutan Lägg till fil, välj Skapa ny fil.

I fältet filnamn anger du namnet och tillägget för mallen. I vår övning använder du namnet azuredeploy.json. Kopiera och klistra in följande mall i din nya GitHub-fil.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "VnetName": {
            "type": "string",
            "defaultValue": "VNet-001",
            "metadata": {
                "description": "Virtual Network Name"
            }
        },
        "CostCenterIO": {
            "type": "string",
            "defaultValue": "12345",
            "metadata": {
                "description": "Cost Center IO number for cross billing"
            }
        },
        "OwnerName": {
            "type": "string",
            "defaultValue": "John Smith",
            "metadata": {
                "description": "Name of the stakeholder responsible for this resource"
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "apiVersion": "2018-10-01",
            "type": "Microsoft.Network/virtualNetworks",
            "name": "[parameters('VnetName')]",
            "location": "[resourceGroup().location]",
            "tags": {
                "CostCenter": "[parameters('CostCenterIO')]",
                "Owner": "[parameters('OwnerName')]"
            },
            "properties": {
                "addressSpace": {
                    "addressPrefixes": [
                        "10.0.0.0/16"
                    ]
                },
                "enableVmProtection": false,
                "enableDdosProtection": false,
                "subnets": [
                    {
                        "name": "subnet001",
                        "properties": {
                            "addressPrefix": "10.0.0.0/24"
                        }
                    },
                    {
                        "name": "subnet002",
                        "properties": {
                            "addressPrefix": "10.0.1.0/24"
                        }
                    }
                ]
            }
        }
    ]
}

Lägg till en beskrivning i avsnittet Kommitt ny fil och välj Kommitt ny fil för att spara den till ditt repo.

Konfigurera autentisering mellan GitHub Actions och din Azure-prenumeration

Om du vill distribuera resurser till Azure med hjälp av GitHub Actions måste du skapa ett Huvudnamn för Azure-tjänsten och ge den behörighet att skapa resurser som definierats i dina mallar. Du utför det steget i avsnittet Azure Cloud Shell i Azure-portalen när du har loggat in på din prenumeration.

Skapa tjänstens huvudnamn

För att huvudansvarig för ett GitHub Actions-arbetsflöde ska kunna distribuera Azure-resurser, behöver det rätt inbyggda bidragsgivare.

Följande Azure CLI-skript visar hur du kan generera ett Azure-tjänsthuvudnamn med bidragsgivarbehörighet i en Azure-resursgrupp. Den här resursgruppen är den plats där arbetsflödet distribuerar de resurser som definierats i ARM-mallen.

projectName="GitHubActionExercise"
location="eastus"
resourceGroupName="${projectName}-rg"
appName="http://${projectName}"

# Create the resource group
az group create --name $resourceGroupName --location $location

# Store the resource group ID in a variable
scope=$(az group list --query "[?contains(name, '$resourceGroupName')].id" -o tsv)

# Create the service principal with contributor rights to the resource group we just created
az ad sp create-for-rbac --name $appName --role Contributor --scopes $scope --sdk-auth

När du är inloggad i din prenumeration i portalen väljer du ikonen Cloud Shell för att öppna gränssnittet längst ned på sidan.

Animering som visar öppnandet av Cloud Shell.

I gränssnittet använder du föregående kod för att skapa tjänstens huvudnamn. Du får följande resultat. Kopiera JSON-delen av resultaten (innehållet i den röda rutan i följande skärmbild) eftersom du behöver det när du konfigurerar hemligheten i GitHub.

Skärmbild som visar resultat för att skapa ett huvudnamn för tjänsten i Azure.

Kopiera JSON-utdata och lagra den som en GitHub-hemlighet på din GitHub-lagringsplats genom att utföra följande steg i GitHub: Välj fliken Inställningar från GitHub-lagringsplatsen. Välj listrutan Hemligheter på den vänstra menyn och välj sedan Codespaces.

Ange följande värden och välj sedan Lägg till hemlighet:

Namn: Ange AZURE_CREDENTIALS.
Secret: Klistra in JSON-utdata som du kopierade tidigare.

Skärmbild som visar hur du lägger till ny hemlig information om tjänstens huvudnamn i en GitHub-hemlighet.

Du behöver den här informationen för att ange autentiseringen i arbetsflödet.

Skapa ett arbetsflöde

Arbetsflödesfilen måste lagras i mappen .github/workflows vid roten av ditt arkiv. Filtillägget för arbetsflödet kan vara antingen .yml eller .yaml.

Du kan skapa en arbetsflödesfil och sedan skicka/ladda upp filen till lagringsplatsen. Eller så kan du använda följande procedur för att skapa den i GitHub-gränssnittet:

Från GitHub-lagringsplatsen väljer du Åtgärder på den översta menyn och väljer Konfigurera ett arbetsflöde själv.
Byt namn på arbetsflödesfilen om du föredrar ett annat namn i stället för main.yml. Använd till exempel deployARMTemplate.yml.
Ersätt innehållet i .yml-filen med följande kod.

Not

GitHub Marketplace har några anpassade åtgärder som du kan använda för att distribuera ARM-mallar. I den här modulen används marketplace-providern Deploy Azure Resource Manager (ARM) Template.
```
name: Deploy ARM Template

on:
  push:
    branches:
      - main
env:
  AZURE_SUBSCRIPTION_ID: << Subscription Id >>   # set this to your Azure Subscription Id
  AZURE_RESOURCE_GROUP: GitHubActionExercise-rg   # set this to your target resource group

jobs:
  deploy-virtual-network-template:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout source code
        uses: actions/checkout@main

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

      - name: Deploy ARM Template
        uses: azure/arm-deploy@v1
        with:
          scope: resourcegroup
          subscriptionId: ${{ env.AZURE_SUBSCRIPTION_ID }}
          resourceGroupName: ${{ env.AZURE_RESOURCE_GROUP }}
          template: ./azuredeploy.json
```
Arbetsflödesfilen har tre avsnitt.
- name: Namnet på arbetsflödet.
- on: Namnet på GitHub-händelsen som utlöser arbetsflödet. Arbetsflödet utlöses när en push-händelse finns på huvudgrenen och ändrar minst en fil på huvudgrenen.
- jobs: En arbetsflödeskörning består av en eller flera uppgifter. Endast ett jobb kallas deploy-virtual-network-template. Det här jobbet har tre steg.
  1. Kolla in källkoden.
  2. Logga in på Azure.
  3. Distribuera den ARM-mallen.
Viktig

Kontrollera att det hemliga namnet i uttrycket creds: ${{ secrets.AZURE_CREDENTIALS }} matchar namnet på hemligheten som du sparade i lagringsplatsens inställningar. Kontrollera också att ARM-mallnamnet i Deploy ARM Template steg template: $GITHUB_WORKSPACE/azuredeploy.json matchar det som du sparade på lagringsplatsen tidigare.

Not

Resursgruppens namn ska vara GitHubActionExercise-rg om du använde föregående Azure CLI-kod när du konfigurerade autentiseringsuppgifter för distribution. Namnet på den genererade resursgruppen är projektnamnet följt av rg.
Välj Starta incheckningen. Lägg till en kommentar och beskrivning om det behövs.
Kontrollera att Checka in direkt till huvudgrenen är markerad och välj sedan Spara ny fil (eller Spara ändringar).

När arbetsflödesfilen har skapats och committerats till huvudgrenen i repositoryt startar arbetsflödet automatiskt eftersom utlösaren i arbetsflödet är en commit/push till huvudgrenen.
```
on:
  push:
    branches:
      - main
```
Gå till lagringsplatsen och kontrollera statusen för arbetsflödet.

Kontrollera din distribution

När arbetsflödet har slutförts går du till Azure-portalen för att kontrollera distributionsstatusen.

I den vänstra rutan väljer du Resursgrupper>GitHubActionExercise-rg. Kontrollera att distributionen lyckades på fliken Distributioner.

Skärmbild som visar distributionsstatus.