Oefening: ARM-sjablonen implementeren als onderdeel van uw CI/CD-activiteiten met GitHub Actions

10 minuten

Hier implementeert u een ARM-sjabloon (Azure Resource Manager) vanuit een GitHub Actions-werkstroom.

Belangrijk

U voert deze oefening buiten de Microsoft Learn-omgeving uit. U hebt uw eigen Azure-abonnement nodig voor deze oefening. Dit kan kosten met zich meebrengen. Dit is vereist omdat u een service-principal moet maken die niet wordt ondersteund in het sandbox-abonnement. Als u nog geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

Uw GitHub-account en -opslagplaats maken

Als u geen GitHub-account hebt, maakt u er nu een op de pagina voor het maken van een GitHub-account. (Dit is gratis.)

Schermopname van de pagina voor het maken van het GitHub-account.

Nadat u een account hebt, meldt u zich aan en maakt u een nieuwe opslagplaats waar u uw sjablonen kunt bewaren als onderdeel van het IaC-model (Infrastructure as Code). Voer de volgende stappen uit om de opslagplaats (ook wel een opslagplaats in de branche genoemd) te maken:

In de rechterbovenhoek van een willekeurige pagina in de GitHub-site gebruikt u de vervolgkeuzelijst + en selecteert u Nieuwe opslagplaats. Of selecteer de groene knop Opslagplaats maken, als deze beschikbaar is.
Voer een korte, goed te onthouden naam in voor uw opslagplaats. Gebruik bijvoorbeeld Implementatie-ARM-sjabloon. U kunt ook een beschrijving van uw opslagplaats toevoegen. Gebruik bijvoorbeeld Mijn eerste ARM-sjabloon met GitHub Actions implementeren.
Kies een zichtbaarheidsinstelling voor de opslagplaats. Openbare opslagplaatsen zijn toegankelijk voor iedereen op internet. Privéopslagplaatsen zijn alleen toegankelijk voor u en personen met wie u expliciet de toegang deelt. (Beide werken met deze oefening.)
Selecteer onder Initialiseer deze opslagplaats met:, selecteer Een README-bestand toevoegen.
Klik op Opslagplaats maken.

U hebt uw opslagplaats gemaakt en deze geïnitialiseerd met een README-bestand. Het is tijd om een sjabloon en een parameterbestand voor de sjabloon door te voeren op de opslagplaats.

Notitie

Leesmij-bestanden zijn een goede plaats om uw project uitvoeriger te beschrijven of om documentatie toe te voegen, zoals instructies voor de installatie of het gebruik van uw project. De inhoud van uw Leesmij-bestand wordt automatisch weergegeven op de voorpagina van uw opslagplaats.

Een ARM-sjabloonbestand doorvoeren in de opslagplaats

Ga op GitHub naar de hoofdpagina van de opslagplaats.
Selecteer boven de bestandenlijst in het vervolgkeuzemenu Bestand toevoegen de optie Nieuw bestand maken.

Voer in het veld Bestandsnaam de naam en extensie voor de sjabloon in. In onze oefening gebruikt u de naam azuredeploy.json. Kopieer en plak de volgende sjabloon in uw nieuwe GitHub-bestand.

{
    "$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"
                        }
                    }
                ]
            }
        }
    ]
}

Voeg in het gedeelte Nieuw bestand doorvoeren een beschrijving toe en selecteer Nieuw bestand doorvoeren om dit op te slaan in uw opslagplaats.

Verificatie tussen GitHub Actions en uw Azure-abonnement configureren

Als u resources wilt implementeren in Azure met behulp van GitHub Actions, moet u een Azure-service-principal maken en deze machtigingen verlenen voor het maken van resources die in uw sjablonen zijn gedefinieerd. U voert deze stap uit in de sectie Azure Cloud Shell van Azure Portal nadat u bent aangemeld bij uw abonnement.

De service-principal maken

De principal van een GitHub Actions-werkstroom kan alleen Azure-resources implementeren met de juiste ingebouwde inzender.

Het volgende Azure CLI-script laat zien hoe u een Azure-service-principal kunt genereren met inzendermachtigingen voor een Azure-resourcegroep. In deze resourcegroep worden met de werkstroom de resources geïmplementeerd die zijn gedefinieerd in uw ARM-sjabloon.

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

Selecteer in de portal, terwijl u bent aangemeld bij uw abonnement, het pictogram Cloud Shell om de shell onderaan de pagina te openen.

Animatie van het openen van Cloud Shell.

Gebruik in de shell de voorgaande code om de service-principal te maken. U krijgt de volgende resultaten. Kopieer het JSON-gedeelte van de resultaten (de inhoud in het rode vak in de volgende schermopname) omdat u dit nodig hebt bij het configureren van het geheim in GitHub.

Schermopname van de resultaten voor het maken van een service-principal in Azure.

Kopieer de JSON-uitvoer en sla deze op als een GitHub-geheim in uw GitHub-opslagplaats door de volgende stappen uit te voeren in GitHub: Selecteer in uw GitHub-opslagplaats het tabblad Instellingen. Selecteer in het linkermenu de vervolgkeuzelijst Geheimen en selecteer vervolgens Codespaces.

Voer de volgende waarden in en selecteer vervolgens Geheim toevoegen:

Naam: Voer AZURE_CREDENTIALS in.
Geheim: Plak de JSON-uitvoer die u eerder hebt gekopieerd.

Schermopname van het toevoegen van nieuwe geheime gegevens van de service-principal aan een GitHub-geheim.

U hebt deze informatie nodig om de verificatie in de werkstroom op te geven.

Een werkstroom maken

Het werkstroombestand moet worden opgeslagen in de map .github/workflows in de hoofdmap van uw opslagplaats. De extensie van een werkstroombestand kan .yml of .yaml zijn.

U kunt een werkstroombestand maken en het vervolgens naar de opslagplaats pushen/uploaden. U kunt ook de volgende procedure gebruiken om dit in de GitHub-interface te maken:

Selecteer in uw GitHub-opslagplaats de optie Acties in het bovenste menu en selecteer Zelf een werkstroom instellen.
Wijzig de naam van het werkstroombestand als u liever een andere naam dan main.yml gebruikt. Gebruik bijvoorbeeld deployARMTemplate.yml.
Vervang de inhoud van het .yml-bestand door de volgende code.

Notitie

De GitHub Marketplace heeft enkele aangepaste ingebouwde acties die u kunt gebruiken voor het implementeren van ARM-sjablonen. In deze module wordt de Marketplace-provider met de naam Arm-sjabloon (Azure Resource Manager) geïmplementeerd.
```
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
```
Het werkstroombestand heeft drie secties.
- name: De naam van de werkstroom.
- on: De naam van de GitHub-gebeurtenis die de werkstroom activeert. De werkstroom wordt geactiveerd wanneer een pushgebeurtenis zich in de hoofdbranch bevindt en ten minste één bestand in de hoofdbranch wijzigt.
- jobs: Een werkstroomuitvoering bestaat uit een of meer taken. Er wordt slechts één taak aangeroepen deploy-virtual-network-template. Deze taak heeft drie stappen.
  1. Broncode voor uitchecken.
  2. Meld u aan bij Azure.
  3. De ARM-sjabloon implementeren.
Belangrijk

Controleer of de geheime naam in de expressie creds: ${{ secrets.AZURE_CREDENTIALS }} overeenkomt met de naam van het geheim dat u hebt opgeslagen in de instellingen van uw opslagplaats. Controleer ook of de naam van de ARM-sjabloon in de Deploy ARM Template-stap template: $GITHUB_WORKSPACE/azuredeploy.json overeenkomt met de naam die u eerder in de opslagplaats hebt opgeslagen.

Notitie

De naam van de resourcegroep moet GitHubActionExercise-rg zijn als u de voorgaande Azure CLI-code hebt gebruikt bij het configureren van de implementatiegegevens. De naam van de gegenereerde resourcegroep is de naam van het project met rg toegevoegd.
Selecteer Doorvoeren starten. Voeg, indien nodig, een opmerking en beschrijving toe.
Zorg ervoor dat Doorvoeren rechtstreeks naar de hoofdbranch is geselecteerd en selecteer vervolgens Nieuw bestand doorvoeren (of Wijzigingen doorvoeren).

Nadat het werkstroombestand is gemaakt en doorgevoerd in de hoofdvertakking van de opslagplaats, wordt de werkstroom automatisch gestart omdat de trigger in uw werkstroom een doorvoering/pushbewerking naar de hoofdvertakking is.
```
on:
  push:
    branches:
      - main
```
Ga naar uw opslagplaats en controleer de status van uw werkstroom.

Uw implementatie controleren

Wanneer de werkstroom is voltooid, gaat u naar Azure Portal om de implementatiestatus te controleren.

Selecteer in het linkerdeelvenster Resourcegroepen>GitHubActionExercise-rg. Controleer in het deelvenster Implementaties of de implementatie is geslaagd.

Schermopname van de implementatiestatus.

Doorgaan