Utiliser un plan Terraform pour déployer une instance Ubuntu Google Cloud Platform et la connecter à Azure Arc

Article
04/03/2023

Cet article propose une aide relative à l’utilisation du plan Terraform fourni pour déployer une instance de Google Cloud Platform (GCP) et la connecter en tant que ressource de serveur avec Azure Arc.

Prérequis

Clonez le référentiel Azure Arc Jumpstart.

git clone https://github.com/microsoft/azure_arc.git

Installez ou mettez à jour Azure CLI vers la version 2.7 ou une version ultérieure. Utilisez la commande suivante pour vérifier la version installée actuellement.
```
az --version
```
Générez une clé SSH (ou utilisez une clé SSH existante).
Créez un compte Google Cloud Platform gratuit.
Installer Terraform >= 0.12
Créez un principal de service Azure.

Pour connecter la machine virtuelle GCP à Azure Arc, un principal de service Azure auquel est affecté le rôle Contributeur est requis. Pour le créer, connectez-vous à votre compte Azure et exécutez la commande suivante. Vous pouvez également exécuter cette commande dans Azure Cloud Shell.
```
az login
az account set -s <Your Subscription ID>
az ad sp create-for-rbac -n "<Unique SP Name>" --role contributor --scopes "/subscriptions/<Your Subscription ID>"
```
Par exemple :
```
az ad sp create-for-rbac -n "http://AzureArcGCP" --role contributor --scopes "/subscriptions/00000000-0000-0000-0000-000000000000"
```
La sortie doit ressembler à ceci :
```
{
  "appId": "XXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "displayName": "http://AzureArcGCP",
  "password": "XXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "tenant": "XXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```
Remarque

Nous vous recommandons vivement d’étendre le principal du service à un abonnement Azure et à un groupe de ressources spécifiques.

Créer un nouveau projet GCP

Accédez à la console d’API Google et connectez-vous avec votre compte Google. Une fois connecté, créez un nouveau projet nommé Azure Arc demo. Après l’avoir créé, veillez à copier l’ID du projet, car il est généralement différent du nom du projet.
Une fois le nouveau projet créé et sélectionné dans la liste déroulante en haut de la page, vous devez activer l’accès à l’API Compute Engine pour le projet. Cliquez sur + Activer les API et les services et recherchez moteur de calcul. Sélectionnez ensuite Activer pour activer l’accès à l’API.
Configurez ensuite une clé de compte de service que Terraform utilisera pour créer et gérer des ressources dans votre projet GCP. Accédez à la page Créer une clé de compte de service. Sélectionnez Nouveau compte de service dans la liste déroulante, attribuez-lui un nom, sélectionnez le projet, puis le rôle Propriétaire et le type de clé JSON et sélectionnez Créer. Cela permet de télécharger un fichier JSON contenant toutes les informations d’identification qui seront nécessaires à Terraform pour gérer les ressources. Copiez le fichier JSON téléchargé dans le répertoire azure_arc_servers_jumpstart/gcp/ubuntu/terraform.
Enfin, assurez-vous que vos clés SSH sont disponibles dans~/.ssh et qu’elles sont nommées id_rsa.pub et id_rsa. Si vous avez suivi le guide ssh-keygen ci-dessus pour créer votre clé, la configuration doit déjà être correcte. Si ce n’est pas le cas, vous devrez peut-être modifier main.tf pour utiliser une clé ayant un chemin différent.

Déploiement

Avant d’exécuter le plan Terraform, vous devez exporter les variables d’environnement qui seront utilisées par le plan. Ces variables sont basées sur le principal de service Azure que vous venez de créer, votre abonnement Azure et votre locataire, ainsi que le nom du projet GCP.

Récupérez votre ID d’abonnement et votre ID de locataire Azure à l’aide de la commande az account list.
Le plan Terraform crée des ressources à la fois dans Microsoft Azure et dans Google Cloud Platform. Il exécute ensuite un script sur une machine virtuelle GCP pour installer l’agent Azure Arc et tous les artefacts nécessaires. Ce script nécessite certaines informations sur vos environnements GCP et Azure. Modifiez scripts/vars.sh et mettez à jour chacune des variables avec les valeurs appropriées.
- TF_VAR_subscription_id = ID de votre abonnement Azure
- TF_VAR_client_id = ID de votre application de principal de service Azure
- TF_VAR_client_secret = mot de passe de votre principal de service Azure
- TF_VAR_tenant_id = ID de votre locataire Azure
- TF_VAR_gcp_project_id = ID du projet GCP
- TF_VAR_gcp_credentials_filename = Nom de fichier JSON des informations d’identification GCP
À partir de l’interface CLI, accédez au répertoire azure_arc_servers_jumpstart/gcp/ubuntu/terraform du référentiel cloné.
Exportez les variables d’environnement que vous avez modifiées en exécutant scripts/vars.sh avec la commande source, comme indiqué ci-dessous. Terraform exige que ces variables soient définies pour que le plan s’exécute correctement. Notez que ce script est également exécuté automatiquement à distance sur la machine virtuelle GCP dans le cadre du déploiement Terraform.
```
source ./scripts/vars.sh
```
Exécutez la commande terraform init qui télécharge le fournisseur Terraform AzureRM.
Exécutez ensuite la commande terraform apply --auto-approve et patientez jusqu’à ce que le plan se termine. Une fois l’opération terminée, une machine virtuelle Ubuntu GCP est déployée et connectée en tant que nouveau serveur avec Azure Arc dans un nouveau groupe de ressources.
Ouvrez le portail Azure et accédez au groupe de ressources arc-gcp-demo. La machine virtuelle créée dans GCP est visible en tant que ressource.

Déploiement semi-automatisé (facultatif)

Comme vous l’avez peut-être remarqué, la dernière étape de l’exécution consiste à inscrire la machine virtuelle en tant que nouvelle ressource de serveur avec Azure Arc.

A screenshot of running the azcmagent connect command.

Si vous souhaitez contrôler le processus d’inscription proprement dit ou en voir une démonstration, procédez comme suit :

Dans le modèle de script install_arc_agent.sh.tmpl, placez en commentaire la section run connect command et enregistrez le fichier.
Récupérez l’IP publique de la machine virtuelle GCP en exécutant terraform output.
Activez SSH sur la machine virtuelle à l’aide de ssh arcadmin@xx.xx.xx.xx où xx.xx.xx.xx est l’adresse IP hôte.
Exportez toutes les variables d’environnement dans vars.sh

Exécutez la commande suivante :

azcmagent connect --service-principal-id $TF_VAR_client_id --service-principal-secret $TF_VAR_client_secret --resource-group "Azure Arc gcp-demo" --tenant-id $TF_VAR_tenant_id --location "westus2" --subscription-id $TF_VAR_subscription_id

A screenshot of the azcmagent connect command completing successfully.

Quand cette opération est effectuée, votre machine virtuelle est inscrite auprès d’Azure Arc et visible dans le groupe de ressources via le portail Azure.

Suppression du déploiement

Pour supprimer toutes les ressources que vous avez créées dans le cadre de cette démonstration, utilisez la commande terraform destroy --auto-approve comme indiqué ci-dessous.

A screenshot of the terraform destroy command.

Vous pouvez également supprimer la machine virtuelle GCP directement à partir de la console GCP.

A screenshot showing how to delete a virtual machine from the GCP console.

Share via