Aller au contenu

Step-1-1 : Déploiement d'une application

Vous avez vu comment créer facilement une instance EC2 de plusieurs manières :

  • Le dashboard AWS Console
  • Le CLI aws
  • Un code terraform

Info

Pour la suite des TPs nous privilégirons désormais toujours l'usage de Terraform mais vous invitons tout de même à aller explorer la console/dashboard AWS afin de savoir y naviguer et visualiser vos resources.

Durant cette étape, nous allons voir comment déployer une application sur notre instance.

Concepts

Il y a beaucoup de façon de deployer des applications sur des serveurs.

Pour commencer, nous pouvons nous connecter en ssh et en lançer nos configurations via des commandes ou scripts. Mais cela n'est pas très maintenable et c'est une méthode manuelle et pas très DevOps.

On préfère automatiser la solution.

Il y a un écosystème très riche et beaucoup d'outils et frameworks concernant cette automatisation une fois les serveurs créés. Parmi les plus répandus, on retrouve Ansible, Chef, Puppet...

Ici, nous allons nous concentrer sur la façon la plus rapide et utilisant les resources du cloud lui-même, les user data.

User Data

Les user data (données utilisateur) sont des scripts ou des instructions lancées au premier démarrage d'une instance EC2. Ces données sont souvent utilisées pour personnaliser et configurer automatiquement une instance EC2 au moment de son démarrage. Par exemple :

  • Installer un logiciel ou des logiciels (docker par exemple)
  • Changer des fichiers
  • Modifier les variables d'environnements
  • Lancer des processus
  • ...

TP

Architecture Applicative

Notre application fil rouge sur cette formation sera une application trois tiers classique appelée Computer Database. Elle est donc composée de :

  • Un front
  • Une API
  • Une base de donnée Postgresql

Pour déployer cette application, nous allons utiliser une approche conteneurisée. Donc ici, nous allons déployer 3 images docker (image OCI) sur notre infrastructure (ici pour commencer une simple instance EC2).

Voici le script permettant de configurer et lancer les différents conteneurs :

Script aws-user-data.sh 
#! /bin/bash

# Install docker https://docs.docker.com/engine/install/ubuntu/#install-using-the-repository
apt-get update
apt-get install -y ca-certificates curl gnupg
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update
apt-get install -y docker-ce docker-ce-cli containerd.io

# Docker post install configuration
groupadd docker
usermod -aG docker ubuntu
newgrp docker

# Start docker service
systemctl start docker.service
systemctl start containerd.service

# Configure Docker to start on boot
systemctl enable docker.service
systemctl enable containerd.service

# Use a private registry (Secret management simplified here, not a best practice)
docker login registry.gitlab.com -p "5t9L4Z9BXvPopSAdysVs" -u "readregcred"

# Setup environment variables
export EC2_PUBLIC_IP=$(curl http://checkip.amazonaws.com)

cat >/home/ubuntu/.env <<EOL
POSTGRES_USER=myuser
POSTGRES_PASSWORD=mypassword
POSTGRES_DB=mydb
DB_ENDPOINT=cdb-db:5432
API_URL=http://${EC2_PUBLIC_IP}:8080
EOL

# Create and start the containers
docker network create cdb-net
docker run -d --name "cdb-db"    --restart always -p 5432:5432 --env-file /home/ubuntu/.env --network cdb-net registry.takima.io/school/proxy/postgres:14
docker run -d --name "cdb-app"   --restart always -p 8080:8080 --env-file /home/ubuntu/.env --network cdb-net registry.gitlab.com/takima-school/images/cdb/api:latest
docker run -d --name "cdb-front" --restart always -p 80:8080   --env-file /home/ubuntu/.env --network cdb-net registry.gitlab.com/takima-school/images/cdb/www:latest

Tip

Pour aller plus loin sachez que les user data permettent passer un fichier cloud-init permettant l'initialisation de l'instance EC2 C'est un standard de plus en plus établi autour de l'initialisation de serveurs.

Tip

Plutôt qu'installer les outils au démarrage il est parfois préférable d'utiliser des images/AMI contenant déjà les outils nécessaires. Ces images peuvent potentiellement déjà exister dans la marketplace AWS ou vous pouvez créer les votres. Il existe même des outils pour faciliter/industrialiser cette création comme Packer

Terraform

Créez une instance EC2 et utilisez les user datas afin de lancer le script fourni précédemment :

L'objectif est de créer le code terraform qui va :

  • Configurer le provider AWS (sur la région eu-west-3)
  • Créer les ressources clefs SSH qui nous permettront de nous connecter au serveur
  • Créer l'instance EC2 en injectant le fichier user data aws-user-data.sh

Tip

Préférez les fonctions file et templatefile pour faciliter la maintenabilité du code terraform et celui du fichier inclu.

Gestion de la clé ssh 
# Generates a secure private key and encodes it as PEM
resource "tls_private_key" "key_pair" {
  algorithm = "RSA"
  rsa_bits  = 4096
}
# Create the Key Pair
resource "aws_key_pair" "key_pair" {
  key_name   = "userid-key-pair"
  public_key = tls_private_key.key_pair.public_key_openssh
}
# Save file
resource "local_file" "ssh_key" {
  filename        = "${aws_key_pair.key_pair.key_name}.pem"
  content         = tls_private_key.key_pair.private_key_pem
  file_permission = "0600" # should be 600 (-rw-------)
}

⚠ Créer une clé comme cela stocke la clé privée en clair dans le tfstate. Plus d'infos ici

Success

Observez via votre browser votre superbe service sur le port 80 de votre ip publique