Exercice - Déployer des modèles ARM dans le cadre de vos efforts CI/CD avec GitHub Actions

Effectué

Ici, vous déployez un modèle Azure Resource Manager (ARM) à partir d’un workflow GitHub Actions.

Important

Cet exercice s’effectue en dehors de l’environnement Microsoft Learn. Vous avez besoin de votre propre abonnement Azure pour effectuer cet exercice, et des frais peuvent vous être facturés. Mais cela est nécessaire, car vous devrez créer un principal de service qui n’est pas pris en charge dans l’abonnement de bac à sable. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Créer votre compte GitHub et votre dépôt

Tout d’abord, si vous n’avez pas de compte GitHub, créez-en un maintenant dans la page de création de compte GitHub. (C’est gratuit.)

Capture d’écran montrant la page de création de compte GitHub.

Une fois que vous avez un compte, connectez-vous et créez un dépôt où vous pouvez conserver vos modèles dans le cadre du modèle d’infrastructure en tant que code (IaC). Pour créer le dépôt (ou repo en anglais), suivez ces étapes :

  1. En haut à droite de n’importe quelle page du site GitHub, utilisez le menu déroulant + et sélectionnez New repository (Nouveau dépôt). Vous pouvez également sélectionner le bouton vert Create repository (Créer un dépôt) si celui-ci est disponible.

    Capture d’écran montrant les sélections à effectuer pour créer un dépôt GitHub.

  2. Entrez un nom court et facile à retenir pour votre dépôt. Par exemple, utilisez Deploy-ARM-Template. Ajoutez éventuellement une description pour votre dépôt. Par exemple, utilisez Déploiement de mon premier modèle ARM avec GitHub Actions.

  3. Choisir un paramètre de visibilité du dépôt. Les dépôts publics sont accessibles à tous sur Internet. Les dépôts privés ne sont accessibles qu’à vous et aux personnes avec lesquelles vous partagez explicitement l’accès. (Les deux options conviennent pour cet exercice.)

  4. Sous Initialiser ce dépôt avec :, sélectionnez Ajouter un fichier LISEZMOI.

  5. Cliquez sur Create repository (Créer le dépôt).

    Capture d’écran montrant les détails de la création d’un dépôt.

Vous avez créé votre dépôt et l’avez initialisé avec un fichier LISEZMOI. Il est temps de commiter un modèle et un fichier de paramètres de modèle pour ce dépôt.

Notes

Les fichiers LISEZMOI sont l’endroit idéal pour décrire votre projet plus en détail ou pour ajouter des documents tels que des consignes d’installation ou d’utilisation de votre projet. Le contenu de votre fichier LISEZMOI apparaît automatiquement dans la page d’accueil de votre dépôt.

Commiter un fichier de modèle ARM pour le dépôt

  1. Sur GitHub, accédez à la page principale du dépôt.

  2. Au-dessus de la liste de fichiers, dans la liste déroulante Add file (Ajouter un fichier), cliquez sur Create new file (Créer un fichier).

    Capture d’écran montrant les sélections à effectuer pour ajouter un modèle au dépôt.

  3. Dans le champ du nom de fichier, entrez le nom et l’extension du modèle. Dans notre exercice, utilisez le nom azuredeploy.json. Copiez et collez le modèle suivant dans votre nouveau fichier GitHub.

    {
        "$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"
                            }
                        }
                    ]
                }
            }
        ]
    }
    
  4. Ajoutez une description dans la section Commit new file (Commiter le nouveau fichier), puis sélectionnez Commit new file pour l’enregistrer dans votre dépôt.

    Capture d’écran montrant l’enregistrement d’un nouveau modèle dans le dépôt.

Configurer l’authentification entre GitHub Actions et votre abonnement Azure

Pour déployer des ressources sur Azure à l’aide de GitHub Actions, vous devez créer un principal de service Azure et lui accorder les autorisations nécessaires pour créer les ressources définies dans vos modèles. Vous effectuez cette étape dans la section Azure Cloud Shell du portail Azure après vous être connecté à votre abonnement.

Créer le principal du service

Le principal d’un workflow GitHub Actions a besoin du droit de contributeur intégré pour déployer des ressources Azure.

Le script Azure CLI suivant montre comment générer un principal de service Azure avec des autorisations de contributeur dans un groupe de ressources Azure. Ce groupe de ressources correspond à l’emplacement où le workflow déploie les ressources définies dans votre modèle ARM.

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

Dans le portail, quand vous êtes connecté à votre abonnement, sélectionnez l’icône Cloud Shell pour ouvrir l’interpréteur de commandes en bas de la page.

Animation montrant l’ouverture de Cloud Shell.

Dans l’interpréteur de commandes, utilisez le code précédent pour créer le principal de service. Vous obtenez les résultats suivants. Copiez la partie JSON des résultats (le contenu du cadre rouge dans la capture d’écran suivante), car vous en avez besoin lors de la configuration du secret dans GitHub.

Capture d’écran montrant les résultats de la création d’un principal de service dans Azure.

Copiez la sortie JSON et stockez-la en tant que secret GitHub dans votre dépôt GitHub en effectuant les étapes suivantes dans GitHub : Dans votre dépôt GitHub, sélectionnez l’onglet Paramètres. Dans le menu de gauche, sélectionnez la liste déroulante Secrets, puis sélectionnez Codespaces.

Entrez les valeurs suivantes, puis sélectionnez Add secret (Ajouter un secret) :

  • Nom : Entrez AZURE_CREDENTIALS.
  • Secret : collez la sortie JSON que vous avez copiée.

Capture d’écran montrant comment ajouter de nouvelles informations relatives au secret du principal de service à un secret GitHub.

Vous avez besoin de ces informations pour spécifier l’authentification dans le workflow.

Créer un workflow

Le fichier de workflow doit être stocké dans le dossier .github/workflows à la racine de votre référentiel. L’extension du fichier de workflow peut être .yml ou .yaml.

Vous pouvez créer un fichier de workflow puis envoyer (push)/charger le fichier vers le dépôt. Vous pouvez également utiliser la procédure suivante pour le créer dans l’interface GitHub :

  1. À partir de votre dépôt GitHub, sélectionnez Actions dans le menu supérieur, puis Set up a workflow yourself (Configurer soi-même un workflow).

    Capture d’écran montrant les sélections à effectuer pour configurer un workflow.

  2. Renommez le fichier de workflow si vous préférez utiliser un nom autre que main.yml. Par exemple, utilisez deployARMTemplate.yml.

  3. Remplacez le contenu du fichier .yml par le code suivant.

    Notes

    La place de marché GitHub propose certaines actions personnalisées que vous pouvez utiliser pour déployer des modèles ARM. Ce module utilise le fournisseur de place de marché appelé 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
    

    Le fichier de workflow comporte trois sections.

    • name : Nom du workflow.

    • on : Nom de l’événement GitHub qui déclenche le workflow. Le workflow est déclenché quand un événement push se trouve sur la branche primaire et modifie au moins un fichier sur cette branche primaire.

    • jobs : Une exécution de workflow se compose d’un ou de plusieurs travaux. Un seul travail est appelé deploy-virtual-network-template. Ce travail comporte trois étapes.

      1. Consulter le code source.
      2. Connectez-vous à Azure.
      3. Déployer le modèle ARM.

    Important

    Vérifiez que le nom du secret dans l’expression creds: ${{ secrets.AZURE_CREDENTIALS }} correspond au nom du secret que vous avez enregistré dans les paramètres de votre dépôt. Vérifiez également que le nom du modèle ARM à l’étape Deploy ARM Templatetemplate: $GITHUB_WORKSPACE/azuredeploy.json correspond à celui que vous avez enregistré précédemment dans le dépôt.

    Notes

    Le nom du groupe de ressources doit être GitHubActionExercise-rg si vous avez utilisé le code Azure CLI précédent quand vous avez configuré les informations d’identification de déploiement. Le nom du groupe de ressources généré est le nom du projet avec le suffixe rg.

  4. Sélectionnez Démarrer la validation. Ajoutez un commentaire et une description si nécessaire.

  5. Vérifiez que Valider directement sur la branche primaire est sélectionné, puis sélectionnez Commit new fileValider un nouveau fichier (ou Valider les modifications).

    Capture d’écran montrant comment valider un workflow dans la branche primaire.

    Une fois le fichier de workflow créé et validé dans la branche primaire du référentiel, le workflow démarre automatiquement car le déclencheur figurant dans votre workflow est une validation/un envoi (push) vers la branche primaire.

    on:
      push:
        branches:
          - main
    
  6. Accédez à votre dépôt et examinez l’état de votre workflow.

    Capture d’écran montrant l’état du workflow.

Vérifier votre déploiement

Une fois le workflow terminé, accédez au portail Azure pour examiner l’état du déploiement.

Dans le volet de gauche, sélectionnez Resource groups (Groupes de ressources)>GitHubActionExercise-rg. Dans le volet Deployments (Déploiements), vérifiez que votre déploiement a réussi.

Capture d’écran montrant l’état du déploiement.