Déploiements automatisés du bundle Meteor.js à l'aide de Terraform

Automatisation du déploiement sur une instance EC2 avec Terraform et Docker

Hé mon pote ! La technologie peut être délicate, mais vous l’avez. Considérez cela comme une conversation technique autour d'un café... ou de mon préféré, le chaay (thé).

Voyons comment automatiser le déploiement de votre projet Meteor.js sur AWS. À la fin, vous vous sentirez comme un ninja du déploiement cloud. Prêt? C'est parti !

Ce dont vous aurez besoin

Avant de retrousser nos manches, rassemblons nos affaires. Voici la liste de contrôle :

1. Identifiants AWS : assurez-vous que l'AWS CLI est configurée et prête à fonctionner.

2. Terraform : Téléchargez et installez Terraform si vous ne l'avez pas déjà fait.

3. Paire de clés SSH : Générez une paire de clés SSH. Conservez la clé privée à portée de main pour vous connecter à votre instance ultérieurement.

4. Nom de domaine : Vous avez un domaine ? Super! Assurez-vous de pouvoir mettre à jour ses enregistrements A.

5. Meteor Bundle : Préparez votre bundle de projet Meteor.js à l'aide de cette commande :
   

   meteor build --server-only --directory ~/path/to/Dockerfile

1. Scripts de configuration : vous aurez besoin de trois scripts pour configurer le serveur :

• server-setup-part1.sh
• mongodb4-setup.sh
• server-setup-part2.sh

Vous avez tout ? Génial! Commençons à construire.

Le plan de jeu

Voici le voyage que nous sommes sur le point de faire :

1. Utilisez Terraform pour lancer une instance EC2 sur AWS.
2. Exécutez quelques scripts pour configurer le serveur, installez MongoDB et déployez votre application Meteor.js à l'aide de Docker.
3. Modifiez vos paramètres DNS pour faire pointer votre domaine vers l'adresse IP du serveur.
4. Finalisez le tout avec la configuration SSL via Certbot.

Assez facile, non ? Décomposons-le étape par étape.

---

Configuration de Terraform

Commencez par organiser votre projet Terraform. Créez une structure de répertoires comme celle-ci :

project-directory/
├── main.tf
├── variables.tf
├── outputs.tf
├── run.sh

Étape 1 : Configuration des variables

Dans variables.tf, définissez toutes les variables dont nous aurons besoin. Ceux-ci rendent la configuration flexible :

variable "server_name" {
  description = "Server created by Terraform"
  type        = string
  default     = "AutomatedDeployment"
}

variable "key_pair_name" {
  description = "Key pair name"
  type        = string
  default     = "tf-key-pair"
}

variable "domain_name" {
  description = "Your domain name"
  type        = string
  default     = "xyz.domain.com"
}

Étape 2 : Le cœur — main.tf

C’est ici que la magie opère. Ce fichier configure tout : l'instance EC2, les groupes de sécurité et les étapes de provisionnement.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "ca-central-1"
}

resource "aws_security_group" "tf-security-group" {
  name        = var.server_name
  description = "Security group for ${var.server_name}"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "tf-created-instance" {
  ami           = "ami-0083d3f8b2a6c7a81"
  instance_type = "t2.micro"
  key_name      = var.key_pair_name
  tags = {
    Name = var.server_name
  }
}

Étape 3 : Résultats

Définissez ce que Terraform doit afficher après son exécution :

output "public_ip" {
  value       = aws_instance.tf-created-instance.public_ip
  description = "The public IP address of the instance"
}

Étape 4 : Script d'automatisation

Dans run.sh, écrivez un script pour automatiser les commandes Terraform et gérer la propagation DNS :

#!/bin/bash
set -e
DOMAIN="your.domain.com"

terraform apply -auto-approve

echo "Waiting for DNS propagation..."
OLD_IP=$(dig +short $DOMAIN)
while true; do
  sleep 10
  NEW_IP=$(dig +short $DOMAIN)
  [ "$NEW_IP" != "$OLD_IP" ] && break
  echo "DNS records not updated yet. Retrying..."
done

terraform apply -auto-approve

Fichier Docker pour Meteor

Voici un exemple de Dockerfile pour empaqueter votre application Meteor.js :

   meteor build --server-only --directory ~/path/to/Dockerfile

Étapes de déploiement

1. Initialiser Terraform : Exécutez cette commande pour configurer Terraform :

project-directory/
├── main.tf
├── variables.tf
├── outputs.tf
├── run.sh

1. Déployer avec l'automatisation : Exécutez le script pour déployer :

variable "server_name" {
  description = "Server created by Terraform"
  type        = string
  default     = "AutomatedDeployment"
}

variable "key_pair_name" {
  description = "Key pair name"
  type        = string
  default     = "tf-key-pair"
}

variable "domain_name" {
  description = "Your domain name"
  type        = string
  default     = "xyz.domain.com"
}

1. Mise à jour DNS :
   Mettez à jour l'enregistrement A de votre domaine pour qu'il pointe vers l'adresse IP publique de l'instance EC2.

2. Vérifier :
   Une fois la propagation DNS terminée, vérifiez votre déploiement en visitant le domaine dans un navigateur.

---

Et voilà ! Un déploiement d'application Meteor.js entièrement automatisé sur AWS à l'aide de Terraform et Docker. N'oubliez pas que chaque défi n'est qu'une autre occasion d'apprendre. Si vous heurtez un rocher, prenez une gorgée de chaay et dépannez comme le pro de la technologie que vous êtes. Célébrez le succès de votre déploiement et publiez-le partout !?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!