Exercices et Projets

---

1 - Exercices pratiques

Exercice 1 : Terraform Multi-Provider

Objectif : Créer une infrastructure sur AWS et Azure avec Terraform.

Solution

# versions.tf
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

provider "aws" {
  region = "eu-west-1"
}

provider "azurerm" {
  features {}
}

# AWS VPC
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  
  tags = {
    Name        = "multicloud-demo"
    Environment = "demo"
  }
}

# Azure Resource Group
resource "azurerm_resource_group" "main" {
  name     = "multicloud-demo"
  location = "westeurope"
}

# Azure VNet
resource "azurerm_virtual_network" "main" {
  name                = "multicloud-vnet"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  address_space       = ["10.1.0.0/16"]
}

output "aws_vpc_id" {
  value = aws_vpc.main.id
}

output "azure_vnet_id" {
  value = azurerm_virtual_network.main.id
}

---

Exercice 2 : ArgoCD Multi-Cluster

Objectif : Déployer une application sur plusieurs clusters K8s.

Solution

# ApplicationSet Multi-Cluster
apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: demo-app
  namespace: argocd
spec:
  generators:
    - list:
        elements:
          - cluster: aws-cluster
            url: https://eks.aws.example.com
          - cluster: azure-cluster
            url: https://aks.azure.example.com
  template:
    metadata:
      name: 'demo-app-{{cluster}}'
    spec:
      project: default
      source:
        repoURL: https://github.com/myorg/demo-app.git
        targetRevision: main
        path: kubernetes
      destination:
        server: '{{url}}'
        namespace: demo
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
          - CreateNamespace=true

# Ajouter les clusters à ArgoCD
argocd cluster add aws-eks-context --name aws-cluster
argocd cluster add azure-aks-context --name azure-cluster

# Appliquer l'ApplicationSet
kubectl apply -f applicationset.yaml

---

Exercice 3 : VPN Cross-Cloud

Objectif : Connecter AWS et GCP via VPN.

Solution

# AWS Side
resource "aws_vpn_gateway" "main" {
  vpc_id = aws_vpc.main.id
}

resource "aws_customer_gateway" "gcp" {
  bgp_asn    = 65000
  ip_address = google_compute_address.vpn.address
  type       = "ipsec.1"
}

resource "aws_vpn_connection" "gcp" {
  vpn_gateway_id      = aws_vpn_gateway.main.id
  customer_gateway_id = aws_customer_gateway.gcp.id
  type                = "ipsec.1"
  static_routes_only  = true
}

# GCP Side
resource "google_compute_vpn_gateway" "main" {
  name    = "vpn-gateway"
  network = google_compute_network.main.id
}

resource "google_compute_address" "vpn" {
  name = "vpn-static-ip"
}

resource "google_compute_forwarding_rule" "esp" {
  name        = "vpn-esp"
  ip_protocol = "ESP"
  ip_address  = google_compute_address.vpn.address
  target      = google_compute_vpn_gateway.main.id
}

resource "google_compute_vpn_tunnel" "aws" {
  name          = "vpn-tunnel-aws"
  peer_ip       = aws_vpn_connection.gcp.tunnel1_address
  shared_secret = aws_vpn_connection.gcp.tunnel1_preshared_key
  
  target_vpn_gateway = google_compute_vpn_gateway.main.id
  
  local_traffic_selector  = ["10.2.0.0/16"]
  remote_traffic_selector = ["10.0.0.0/16"]
}

---

Exercice 4 : Monitoring Unifié

Objectif : Centraliser les métriques de plusieurs clouds avec Prometheus et Thanos.

Solution

# Prometheus par cluster avec remote write
# values-prometheus-aws.yaml
prometheus:
  prometheusSpec:
    externalLabels:
      cluster: aws-prod
      cloud: aws
    remoteWrite:
      - url: http://thanos-receive:19291/api/v1/receive

# Thanos Query
apiVersion: apps/v1
kind: Deployment
metadata:
  name: thanos-query
spec:
  template:
    spec:
      containers:
        - name: thanos-query
          image: quay.io/thanos/thanos:v0.32.0
          args:
            - query
            - --store=prometheus-aws:10901
            - --store=prometheus-azure:10901

# Grafana Dashboard
{
  "panels": [
    {
      "title": "Requests by Cloud",
      "targets": [
        {
          "expr": "sum(rate(http_requests_total[5m])) by (cloud)"
        }
      ]
    }
  ]
}

---

2 - Projet complet : Application Multi-Cloud

Architecture

Structure du projet

multicloud-project/
├── terraform/
│   ├── aws/
│   │   ├── main.tf
│   │   ├── eks.tf
│   │   ├── rds.tf
│   │   └── s3.tf
│   ├── azure/
│   │   ├── main.tf
│   │   ├── aks.tf
│   │   └── database.tf
│   ├── shared/
│   │   ├── cloudflare.tf
│   │   └── vault.tf
│   └── modules/
│       └── ...
├── kubernetes/
│   ├── base/
│   │   ├── deployment.yaml
│   │   ├── service.yaml
│   │   └── kustomization.yaml
│   └── overlays/
│       ├── aws-prod/
│       └── azure-dr/
├── argocd/
│   └── applicationset.yaml
├── monitoring/
│   ├── prometheus/
│   ├── thanos/
│   └── grafana/
└── docs/
    ├── architecture.md
    └── runbooks/

Étapes de mise en œuvre

1. Infrastructure de base

   • Déployer les VPCs/VNets
   • Configurer le VPN cross-cloud
   • Déployer les clusters Kubernetes

2. Plateforme

   • Installer ArgoCD
   • Configurer Vault
   • Déployer le monitoring

3. Application

   • Déployer l'application via ArgoCD
   • Configurer les databases
   • Mettre en place la réplication

4. Traffic Management

   • Configurer CloudFlare
   • Tester le failover
   • Valider le DR

---

3 - Quiz de révision

1. Quelle est la différence entre Multi-Cloud et Hybrid Cloud ?

2. Pourquoi utiliser Terraform plutôt que les outils natifs de chaque cloud ?

3. Comment éviter le vendor lock-in ?

4. Qu'est-ce que la Data Gravity ?

5. Quels outils permettent le monitoring Multi-Cloud unifié ?

Réponses

1. Multi-Cloud : plusieurs clouds publics. Hybrid Cloud : cloud public + on-premises.

2. Terraform offre une syntaxe unifiée pour tous les clouds, facilitant la gestion et réduisant la complexité.

3. Utiliser des abstractions portables (Kubernetes, Terraform), des standards ouverts (PostgreSQL, Kafka), éviter les services propriétaires sans alternative.

4. Les données massives attirent les workloads car déplacer les données est coûteux et lent. Il vaut mieux déplacer le compute vers les données.

5. Datadog, Grafana Cloud, Prometheus + Thanos, Elastic Stack, New Relic.

---

4 - Certifications recommandées

Multi-Cloud

Certification	Fournisseur	Focus
HashiCorp Terraform Associate	HashiCorp	IaC Multi-Cloud
CKA/CKAD	CNCF	Kubernetes
AWS Solutions Architect	AWS	Architecture AWS
Azure Solutions Architect	Microsoft	Architecture Azure
GCP Professional Cloud Architect	Google	Architecture GCP

Parcours recommandé

1. Terraform Associate - Foundation IaC
2. CKA - Kubernetes Administration
3. 1 certification cloud selon votre focus
4. 2ème certification cloud pour diversifier

---

Résumé du cours

Félicitations ! Vous avez complété le cours Multi-Cloud.

Vous maîtrisez maintenant :

• Les stratégies Multi-Cloud
• Terraform pour infrastructure multi-provider
• Kubernetes multi-cluster avec ArgoCD/Istio
• Le networking cross-cloud
• L'IAM et les secrets
• La gestion des données
• Le monitoring unifié

Prochaines étapes

• Pratiquer avec des labs hands-on
• Passer les certifications
• Contribuer à des projets open source
• Rejoindre des communautés (CNCF, HashiCorp)

---

← Retour à la table des matières