Intro à l'infrastructure en tant que code - IaC - avec Twilio (Partie 2)

Produits

TaskRouter

Temps de lecture: 8 minutes

May 19, 2021

Rédigé par

Maria Bermudez

Twilion

Kaique Lupo

Twilion

Giuseppe Verni

Twilion

Intro à l'infrastructure en tant que code - IaC - avec Twilio (Partie 2)

Présentation de l'infrastructure en tant que code - IaC - avec Twilio (Partie 2)

Dans la première partie de cette série, nous avons abordé les principes de base de l'infrastructure en tant que code (IaC), puis nous avons créé et déployé notre premier script. Dans cette partie de la série, nous allons voir comment l'IaC peut vous aider dans différentes phases de développement.

Conditions préalables

Pour suivre cette procédure, vous devez disposer des éléments suivants :

Un compte Twilio (que vous pouvez essayer gratuitement)
La CLI Twilio
La La CLI Pulumi
Un compte Pulumi (que vous pouvez également essayer gratuitement)
Un compte Azure DevOps (vous aurez besoin d'une organisation, d'un projet et d'un répertoire dans un projet) ou un compte GitHub

Vous avez également besoin du plug-in Twilio CLI Infra. Vous pouvez l'installer à l'aide de la commande suivante :

$ twilio plugins:install twilio-infra-as-code/plugin-twilio-infra

Si vous avez déjà installé le plug-in Infra, assurez-vous d'utiliser la version 0.2.0 ou une version ultérieure. Pour vérifier la version du plug-in que vous exécutez, utilisez la commande suivante :

$ twilio plugins

Vous devriez voir le résultat suivant :

plugin-twilio-infra 0.2.0

Gérer plusieurs environnements de préparation

Dans un cycle de développement classique, les développeurs sont invités à tester leur implémentation dans un environnement de préparation, puis à les déployer dans un environnement de production. Dans cette section, nous allons voir comment travailler avec des environnements et l'IaC.

Commençons par la phase de test : en tant que développeur, votre homologue peut vous demander de réviser son code. Vous pouvez souhaiter déployer le code dans votre propre environnement de test pour vous assurer qu'il est robuste. Dans un environnement traditionnel, cela implique de s'assurer que tous les environnements de test de tous les développeurs sont alignés, ce qui peut être assez difficile, surtout lorsque de nouvelles fonctionnalités sont introduites.

L'IaC peut faciliter cela, car la configuration de l'environnement est vérifiée avec le code. Voyons comment cela fonctionne en suivant les étapes ci-dessous :

Vérifier la configuration du code et de l'environnement
Définir un nouvel environnement de test (ou utiliser un environnement précédemment défini)
Déployer les ressources et effectuer des tests
Passer à un nouvel environnement (par exemple, production)
Déployer les ressources en production

Dans Twilio, un environnement de préparation est généralement mappé à un projet / compte Twilio (vous pouvez lire plus de détails sur Mise en route avec des projets et sous-comptes Twilio). Pour suivre cet exemple, vous aurez besoin de deux comptes Twilio : un pour les tests et un pour la production.

Commençons par télécharger le code (nous supposons qu'il est écrit par un autre développeur pour cet exercice). Vous pouvez récupérer l'exemple de code en clonant ce répertoire, ou en réutilisant le code que vous avez créé dans la partie 1 de cette série.

Avant de commencer, installons les dépendances :

$ npm install

Créer un nouvel environnement

Une fois que vous avez le code localement, vérifiez que vous utilisez le bon projet Twilio pour l'environnement de test, en exécutant :

$ twilio profiles:list

Si vous n'utilisez pas le bon profil, basculez sur le profil que vous souhaitez utiliser en exécutant :

$ twilio profiles:use <profile_name>

Utilisons à présent la CLI Twilio pour créer un nouvel environnement appelé test :

$ twilio infra:environment:new test

Si tout s'exécute correctement, vous devriez voir le résultat suivant :

🎉 New environment created. When you are ready, use

 $ twilio infra:deploy

to deploy it to your Twilio project

Si vous consultez le répertoire racine, un nouveau fichier nommé .twilio-infra s'affiche. Si vous ouvrez ce fichier, vous devriez voir quelque chose comme suit :

{
   "ACxxxxxxxxxxxxxxxxxxxxxxxxxxx":{
      "environment":"test",
      "deployed":false
   }
}

Ce fichier assure le suivi du mappage entre les environnements de projet Twilio et leurs informations d'état de déploiement.

Vous pouvez maintenant déployer vos ressources Twilio à l'aide des éléments suivants :

$ twilio infra:deploy

Si vous examinez à nouveau le fichier .twilio-infra, vous verrez que l'attribut déployé a changé en true, pour indiquer que le projet a été déployé.

Déployer en production

Une fois que vous avez effectué vos tests dans l'environnement de préparation, vous êtes prêt à déployer en production. Dans ce cas précis, nous n'avons pas d'environnement de production défini pour le projet, nous devons donc en créer un. Dans les environnements réels, la production est généralement suivie sur un environnement de stockage partagé (par exemple, le back-end Pulumi, dont nous parlerons plus tard).

Avant de créer un nouvel environnement, la première étape consiste à passer à un autre projet. Si un projet Twilio est déjà associé à un environnement précédemment déployé, le plug-in CLI empêche la définition d'un nouvel environnement sur le même projet.

Utilisons la commande suivante pour sélectionner un nouveau projet Twilio que nous utiliserons pour notre déploiement de production :

$ twilio profiles:use <profile_name>

Vous pouvez désormais utiliser la commande twilio infra:environment:new pour créer un nouvel environnement (nous l'appellerons prod) et twilio infra:deploy pour le déployer sur votre projet de production Twilio.

Basculer entre les environnements

Si vous souhaitez à présent revenir à l'environnement test, vous pouvez utiliser la commande suivante :

$ twilio infra:environment:set test

Assurez-vous également de sélectionner le profil de la CLI Twilio approprié avant d'effectuer des déploiements.

Si vous n'êtes pas sûr de l'environnement actuellement défini, vous pouvez vérifier en exécutant la commande suivante :

$ twilio infra:environment:get

Utiliser l'IaC dans un environnement DevOps

Jusqu'à présent, nous avons utilisé l'IaC avec Twilio dans un environnement local. La plupart du temps, vous utiliserez un outil DevOps pour mettre en œuvre vos pipelines CI/CD. Dans cet article, nous allons utiliser Azure DevOps, mais vous pouvez facilement adapter cet exemple pour utiliser d'autres produits.

Créer un nouveau projet à l'aide du stockage back-end dans le cloud

Étant donné que nous allons utiliser un service cloud pour exécuter notre pipeline, nous devons disposer d'un service cloud pour stocker les métadonnées de configuration IaC. Dans cet exemple, nous allons utiliser le service Pulumi pour notre back-end. Si vous ne l'avez pas déjà fait, rendez-vous sur la page d'inscription Pulumi pour l'essayer gratuitement.

Si vous utilisiez auparavant le stockage local pour Pulumi, utilisez la commande suivante pour vous déconnecter :

$ pulumi logout

Une fois que vous êtes déconnecté, utilisez la commande suivante pour vous connecter au stockage back-end Pulumi :

$ pulumi login

Suivez les étapes pour autoriser votre ordinateur à se connecter à votre compte Pulumi à partir de la CLI.

Initialisons maintenant un nouveau projet. Créez un nouveau dossier vide (par exemple my-second-iac-project) et saisissez la commande suivante à l'intérieur :

$ twilio infra:new

Après avoir suivi les invites et initialisé le projet, vous devriez voir votre nouveau projet dans l'onglet Projects (Projets) du tableau de bord Pulumi :

Modifiez le fichier index.js et insérez le code suivant :

'use strict';
const pulumi = require('@pulumi/pulumi');

const { Resource } = require('twilio-pulumi-provider');

const workspace = new Resource('example-workspace', {
  resource: ['taskrouter', 'workspaces'],
  attributes: {
    friendlyName: 'New Workspace created with Pulumi',
  },
});

Il s'agit d'une version simplifiée du code que nous avons créé dans la partie 1. N'hésitez pas à réutiliser le code complet que vous avez écrit auparavant.

Nous sommes maintenant prêts à créer notre pipeline. Dans cet article, nous allons présenter deux intégrations :

Pipeline Azure DevOps
Actions GitHub

Les deux plateformes disposent d'un niveau gratuit, mais dans le cas d'Azure DevOps, vous devrez activer la facturation dans votre compte pour utiliser le pipeline.

Créer un nouveau token d'accès Pulumi

Les deux plates-formes exécutent des commandes Pulumi à partir d'un exécuteur cloud (cloud runner). Pour assurer le suivi des ressources déployées, la CLI Pulumi doit accéder au back-end Pulumi. Pour ce faire, nous devons créer un token d'accès en suivant la procédure ci-dessous :

Accédez à la page des tokens d'accès Pulumi
Cliquez sur le bouton « Create New token » (Créer un nouveau token)
Donnez-lui un nom (par exemple pipeline) et cliquez sur « Create Token » (Créer un token)
Copiez le token et enregistrez-le en lieu sûr.

Nous utiliserons ce token d'accès ultérieurement pour configurer notre pipeline.

Créer un nouveau pipeline dans Azure DevOps

Pour vous inscrire à Azure DevOps, rendez-vous sur la page principale d'Azure DevOps et cliquez sur « Start free » (Démarrer gratuitement). Après avoir créé votre compte gratuit dans Azure DevOps, créez un nouveau projet appelé twilio-infra-blog. Azure DevOps va créer un nouveau répertoire pour vous, accessible à partir des icônes de répertoire dans la barre de gauche. Vous pouvez maintenant suivre les instructions pour télécharger les fichiers via git ou utiliser le bouton « Initialize » pour initialiser le répertoire et charger les fichiers manuellement. Quel que soit votre choix, veillez à télécharger/valider les fichiers suivants dans le répertoire Git dans Azure DevOps :

Pulumi.yml
index.js
package.json

Pulumi fournit une extension de tâche pour Azure DevOps que vous pouvez utiliser pour exécuter vos applications Pulumi en tant que tâche build and release (créer et publier). Installez cette extension sur votre organisation en cliquant sur le bouton « Get it » (Obtenir) sur la page Extension de tâche Pulumi. Étant donné que Pulumi fournit déjà cette extension de tâche, nous allons ignorer l'utilisation de la CLI Twilio.

Créer un pipeline

Nous devons maintenant expliquer à Azure DevOps ce qu'il faut faire avec l'application Pulumi :

Accédez au groupe Pipelines dans le système de navigation gauche Azure DevOps et cliquez sur « Create Pipeline » (Créer un pipeline)
Sélectionnez « Azure Repos Git » (Répertoires Git Azure) comme emplacement de votre code
Sélectionnez le répertoire que vous venez de créer (par exemple twilio-infra-blog)
Sélectionnez « Node.js » comme configuration de pipeline.

Un nouveau fichier azure-pipeline.yml sera créé. Remplacez le contenu de ce fichier par le code suivant :

jobs:
- job: infrastructure
  pool:
    vmImage: 'ubuntu-16.04'
  steps:
  - task: Npm@1
    inputs:
      command: install
      workingDir: "./"
  - task: Pulumi@1
    condition: or(eq(variables['Build.Reason'], 'IndividualCI'), eq(variables['Build.Reason'], 'Manual'))
    inputs:
      command: 'up'
      cwd: './'
      stack: 'dev'
      args: '--yes'
  - script: |
      echo "##vso[task.setvariable variable=resourceGroupName;isOutput=true]$(pulumi stack output resourceGroupName)"
      echo "##vso[task.setvariable variable=storageAccountName;isOutput=true]$(pulumi stack output storageAccountName)"
      echo "##vso[task.setvariable variable=containerName;isOutput=true]$(pulumi stack output containerName)"      
    displayName: 'Set stack outputs as variables'
    name: 'pulumi'

Examinons les tâches définies dans ces fichiers :

Tout d'abord, ils utilisent la tâche Npm pour installer toutes les dépendances définies dans package.json
La deuxième tâche consiste à utiliser l'extension de tâche Pulumi pour exécuter la commande up. Il s'agit de l'équivalent de la commande twilio infra:deploy utilisée dans nos exemples de déploiement précédents. Dans cette commande, nous spécifions également les éléments suivants :

stack : vous définissez ici le nom que nous avons donné à l'environnement au début de cet article
condition : il s'agit de la condition qui déclenchera l'exécution de ce pipeline. Nous exécutons cette étape en particulier lorsque nous validons quelque chose au niveau de la branche principale (IndividualCI) ou lorsque nous déclenchons le travail manuellement (Manual)

Définir les variables

Nous devons maintenant définir certaines variables qui seront utilisées par le pipeline. Dans le coin supérieur droit, cliquez sur « Variables » et ajoutez les variables suivantes. Assurez-vous de sélectionner « Keep this value secret » (Garder cette valeur secrète) avant d'enregistrer la variable.

PULUMI_ACCESS_TOKEN : token que vous avez créé dans le tableau de bord Pulumi
TWILIO_ACCOUNT_SID : SID du compte Twilio sur lequel vous souhaitez déployer vos ressources (assurez-vous que ce compte ne contient aucune ressource créée via le même fichier)
TWILIO_AUTH_TOKEN : token d'authentification du compte Twilio spécifié ci-dessus

Exécuter votre pipeline

Maintenant que vous avez défini les étapes et configuré les variables d'environnement, vous pouvez exécuter votre pipeline. Cliquez sur « Save and run » (Enregistrer et exécuter) dans le coin supérieur droit de la page. Dans la page qui s'ouvre, cliquez sur les pipelines en cours d'exécution pour voir la progression. À la fin, vous devriez voir quelque chose comme la capture d'écran ci-dessous :

Et si vous ouvrez votre compte Twilio, vous verrez que le workflow a été créé.

À titre de test, vous pouvez maintenant essayer de mettre à jour les ressources dans le fichier index.js (en modifiant le nom du collaborateur comme nous l'avons fait dans la partie 1 par exemple), et voir comment le pipeline s'exécute automatiquement une fois que vous avez validé le fichier. Les ressources de votre compte Twilio changent en conséquence.

Créer un nouveau pipeline avec les actions GitHub

Pour commencer, connectez-vous à votre compte GitHub et créez un nouveau répertoire. Pour suivre la procédure, vous pouvez utiliser l'interface Web ou git pour ajouter les fichiers suivants au répertoire :

Pulumi.yaml
index.js
package.json

Désormais, dans le même répertoire, créez un dossier appelé .github suivi d'un sous-dossier appelé workflows. Ensuite, dans le répertoire workflows, créez un fichier appelé push.yaml dans ce dossier. Le contenu du fichier doit être le suivant :

name: Deploy resources
on:
  push:
    branches:
      - main
jobs:
  up:
    name: Update
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
        with:
          fetch-depth: 1
      - uses: actions/setup-node@v1
        with:
          node-version: 12.x
      - name: Install Pulumi CLI
        uses: pulumi/action-install-pulumi-cli@v1
      - run: npm install
      - uses: pulumi/actions@v3
        with:
          command: up
          stack-name: dev
        env:
          PULUMI_ACCESS_TOKEN: ${{ secrets.PULUMI_ACCESS_TOKEN }}
          TWILIO_AUTH_TOKEN: ${{ secrets.TWILIO_AUTH_TOKEN }}
          TWILIO_ACCOUNT_SID: ${{ secrets.TWILIO_ACCOUNT_SID }}

Ce flux de travail « Update » (Mise à jour) est déclenché lorsqu'une nouvelle validation est envoyée à la branche main. Pour en savoir plus sur les déclencheurs et les branches, reportez-vous à la section Syntaxe du flux de travail pour les actions GitHub.

Validez maintenant ce fichier et ouvrez l'onglet « Settings » (Paramètres) du répertoire GitHub. Dans la barre de navigation de gauche, cliquez sur Secrets et ajoutez les variables suivantes :

PULUMI_ACCESS_TOKEN : token que vous avez créé dans le tableau de bord Pulumi
TWILIO_ACCOUNT_SID : SID du compte Twilio sur lequel vous souhaitez déployer vos ressources (assurez-vous que ce compte ne contient aucune ressource créée via le même fichier)
TWILIO_AUTH_TOKEN : token d'authentification du compte Twilio spécifié ci-dessus

Vous êtes maintenant prêt à exécuter les actions dans votre flux de travail GitHub. Cliquez sur l'onglet « Actions » du répertoire. Il se peut que vous voyiez un flux de travail ayant échoué sur la liste. Cliquez dessus, puis cliquez sur Re-run jobs > Re-run all jobs (Réexécuter les tâches > Réexécuter toutes les tâches). Une autre façon de tester le flux de travail consiste à ajouter un autre fichier de test, à le valider, puis à le transférer vers la branche main. Vous devriez voir une autre exécution de flux de travail ajoutée à la file d'attente.

Points à retenir

Vous pouvez considérer votre projet Twilio comme un environnement twilio infra. La CLI Twilio vous permet de basculer facilement entre vos environnements de préparation et de production.
Vous disposez de différentes options pour gérer vos ressources IaC : utilisez le stockage local, puis déployez et gérez vos ressources sur votre compte Twilio à l'aide du plug-in CLI Twilio infra, ou utilisez le back-end Pulumi pour gérer vos ressources d'infrastructure.
Pulumi offre une intégration avec diverses plateformes pour les pipelines CI/CD : dans ce post, nous n'en avons vu que deux. Découvrez les guides de livraison continue de Pulumi pour l'intégration avec d'autres plateformes.

Articles associés

Ressources connexes

Twilio Docs

Des API aux SDK en passant par les exemples d'applications

Documentation de référence sur l'API, SDK, bibliothèques d'assistance, démarrages rapides et didacticiels pour votre langage et votre plateforme.

Centre de ressources

Les derniers ebooks, rapports de l'industrie et webinaires

Apprenez des experts en engagement client pour améliorer votre propre communication.

Ahoy

Le hub de la communauté des développeurs de Twilio

Meilleures pratiques, exemples de code et inspiration pour créer des expériences de communication et d'engagement numérique.