TD3 : Stack applicative 3 tiers avec Terraform et Ansible

• Provisionner une stack front / back / db avec Terraform
• Configurer chaque service avec Ansible
• Utiliser les groupes, variables et handlers Ansible
• Comprendre l'ordre d'execution entre services dependants

Vous travaillez dans une equipe DevOps pour une startup.

L'equipe doit deployer un environnement de developpement compose de :

• un frontend NGINX (page statique)
• un backend Python Flask
• une base de donnees PostgreSQL

Probleme actuel :

• les developpeurs configurent les services a la main
• les environnements different d'une machine a l'autre
• le backend demarre avant la base de donnees et plante

Objectif :

Automatiser le deploiement et la configuration de la stack complete.

Creer la structure suivante :

mkdir td3-stack
cd td3-stack
mkdir terraform ansible

Structure attendue :

td3-stack/
  terraform/
    main.tf
    variables.tf
    outputs.tf
  ansible/
    inventory.ini
    playbook.yml
    group_vars/
      frontend.yml
      backend.yml
      database.yml

Le fichier terraform/main.tf vous est fourni avec le frontend et le backend.

Fichier : terraform/main.tf

terraform {
  required_providers {
    docker = {
      source = "kreuzwerker/docker"
    }
  }
}

provider "docker" {}

# --- Images ---

resource "docker_image" "nginx" {
  name = "nginx:latest"
}

resource "docker_image" "flask" {
  name = "python:3.11-slim"
}

# A COMPLETER : image PostgreSQL
# resource "docker_image" "postgres" { ... }

# --- Reseau commun ---

resource "docker_network" "stack" {
  name = "td3-network"
}

# --- Frontend ---

resource "docker_container" "frontend" {
  name  = "frontend"
  image = docker_image.nginx.name

  networks_advanced {
    name = docker_network.stack.name
  }

  ports {
    internal = 80
    external = 8080
  }
}

# --- Backend ---

resource "docker_container" "backend" {
  name  = "backend"
  image = docker_image.flask.name

  networks_advanced {
    name = docker_network.stack.name
  }

  ports {
    internal = 5000
    external = 5000
  }

  command = ["sleep", "infinity"]
}

# A COMPLETER : conteneur PostgreSQL
# resource "docker_container" "database" { ... }
# port interne : 5432
# port externe : 5432
# variable d'environnement : POSTGRES_PASSWORD = "devpass"

Fichier : terraform/variables.tf

variable "db_password" {
  description = "Mot de passe PostgreSQL"
  default     = "devpass"
}

Fichier : terraform/outputs.tf

output "frontend_url" {
  value = "http://localhost:8080"
}

output "backend_url" {
  value = "http://localhost:5000"
}

output "database_host" {
  value = "localhost"
}

cd terraform
terraform init
terraform plan
terraform apply

docker ps

Fichier : ansible/inventory.ini

[frontend]
localhost ansible_connection=local

[backend]
localhost ansible_connection=local

[database]
localhost ansible_connection=local

Fichier : ansible/group_vars/frontend.yml

container_name: frontend
service_port: 8080
env_label: "Developpement"

Fichier : ansible/group_vars/backend.yml

container_name: backend
service_port: 5000
db_host: database
db_port: 5432

Fichier : ansible/group_vars/database.yml

container_name: database
db_user: postgres
db_name: appdb

Fichier : ansible/playbook.yml

---
- name: Configuration du frontend
  hosts: frontend
  gather_facts: false

  tasks:
    - name: Copier la page HTML du frontend
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: >
          bash -c "echo '<h1>{{ env_label }}</h1>
          <p>Frontend actif sur le port {{ service_port }}</p>'
          > /usr/share/nginx/html/index.html"
      notify: Recharger nginx

  handlers:
    - name: Recharger nginx
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: nginx -s reload

- name: Configuration du backend
  hosts: backend
  gather_facts: false

  tasks:
    - name: Installer Flask
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: pip install flask psycopg2-binary

    - name: Copier l'application Flask
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: >
          bash -c "cat > /app.py << 'EOF'
          from flask import Flask
          app = Flask(__name__)

          @app.route('/')
          def index():
              return 'Backend actif. DB: {{ db_host }}:{{ db_port }}'

          if __name__ == '__main__':
              app.run(host='0.0.0.0', port={{ service_port }})
          EOF"

    - name: Demarrer Flask
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: bash -c "nohup python /app.py &"

- name: Configuration de la base de donnees
  hosts: database
  gather_facts: false

  tasks:
    - name: Creer la base de donnees applicative
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: >
          psql -U {{ db_user }} -c "CREATE DATABASE {{ db_name }};"

cd ansible
ansible-playbook -i inventory.ini playbook.yml

La tache de creation de base de donnees peut echouer si PostgreSQL n'est pas encore pret.

Modifier le play database dans ansible/playbook.yml :

Fichier : ansible/playbook.yml (section database uniquement)

- name: Configuration de la base de donnees
  hosts: database
  gather_facts: false

  tasks:
    - name: Attendre que PostgreSQL soit pret
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: pg_isready -U postgres
      register: pg_ready
      until: pg_ready.rc == 0
      retries: 10
      delay: 3

    - name: Creer la base de donnees applicative
      community.docker.docker_container_exec:
        container: "{{ container_name }}"
        command: >
          psql -U {{ db_user }} -c "CREATE DATABASE {{ db_name }};"

Un handler ne se declenche que si la tache associee a effectue un changement.