15 min de lecture

Objectifs d'apprentissage

À la fin de ce module, vous serez en mesure de:

  • Définir des Network Security Groups et leurs règles avec `ionoscloud_nsg` et `ionoscloud_nsg_firewallrule`, et de les attacher aux cartes réseau des serveurs
  • Provisionner un Managed Application Load Balancer avec `ionoscloud_application_loadbalancer`, une règle de transfert et un groupe de cibles
  • Configurer le routage HTTP basé sur le chemin et les vérifications d'état pour l'API de TaskBoard dans le code
  • Provisionner un Managed Network Load Balancer avec `ionoscloud_networkloadbalancer` et choisir entre NLB et ALB
  • Protéger les serveurs équilibrés par des règles au niveau de la carte réseau qui n'admettent que l'adresse privée de l'équilibreur de charge

Unité 2.3 : Équilibrage de charge et sécurité en tant que code

Introduction

Le réseau de TaskBoard de l'unité 2.2 sépare les niveaux, mais tout ce qui se trouve à l'intérieur du LAN de l'application peut encore accéder à tous les ports du serveur API, et les clients se connectent toujours à un seul serveur. Avant d'ajouter un second serveur API, vous avez besoin d'un Load Balancer devant l'API et de règles de pare-feu que vous pouvez examiner dans une pull request.

Dans cette unité, vous écrivez les deux sous forme de code. Les Network Security Groups (NSG) contiennent des règles de pare-feu avec état qui s'appliquent aux serveurs et aux NIC. Le Managed Application Load Balancer (ALB) achemine les requêtes HTTP par chemin vers des groupes de cibles avec des contrôles d'intégrité, et le Managed Network Load Balancer (NLB) distribue le trafic TCP. Les deux Load Balancer sont des ressources Terraform à part entière que vous provisionnez séparément des serveurs situés derrière eux. Dans le Code Lab, vous placez un ALB devant l'API de TaskBoard et verrouillez le niveau application avec un NSG.

1. Network Security Groups en tant que code

resource "ionoscloud_nsg" "app" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  name          = "taskboard-app"
  description   = "App tier: HTTP from the ALB only"
}

resource "ionoscloud_nsg_firewallrule" "app_http_from_alb" {
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.app.id
  name             = "http-from-alb"
  type             = "INGRESS"
  protocol         = "TCP"
  source_ip        = "10.10.1.6"
  port_range_start = 80
  port_range_end   = 80
}

resource "ionoscloud_nsg_firewallrule" "app_egress" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  nsg_id        = ionoscloud_nsg.app.id
  name          = "egress-all"
  type          = "EGRESS"
  protocol      = "ANY"
}

Un NSG possède un refus par défaut : les règles n'autorisent que le trafic, et tout trafic non explicitement autorisé est bloqué. Cela s'applique aux deux directions, ce qui explique pourquoi l'exemple ajoute également une règle de trafic sortant. Les pare-feu NSG sont à état, de sorte que les réponses à une connexion autorisée passent sans règle propre.

1.1 Arguments des règles

Argument Obligatoire Remarques
nsg_id, datacenter_id Oui Le NSG et son VDC
protocol Oui TCP, UDP, ICMP ou ANY ; le modifier force une nouvelle règle
type Non INGRESS (par défaut) ou EGRESS
source_ip, target_ip Non Une adresse IPv4 chacune ; null autorise tout
port_range_start, port_range_end Non Pour TCP et UDP ; laisser les deux à null pour autoriser tous les ports
icmp_type, icmp_code Non Pour ICMP uniquement

Comme le montre le tableau, une règle correspond à une seule adresse source. Pour une couche avec plusieurs clients, rédigez une règle par client, ou générez-les avec for_each :

resource "ionoscloud_nsg_firewallrule" "db_from_app" {
  for_each         = toset(["10.10.2.11", "10.10.2.21"]) # DB-LAN NICs, Unit 2.5
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.db.id
  name             = "pg-from-${each.value}"
  protocol         = "TCP"
  source_ip        = each.value
  port_range_start = 5432
  port_range_end   = 5432
}

1.2 Association des NSG aux serveurs et aux NIC

Les NIC et les VM peuvent être des membres d'un NSG. Lorsqu'une VM est membre, toutes ses NIC héritent des règles. Pour protéger uniquement l'interface de la couche applicative du serveur API, associez le NSG à cette NIC :

resource "ionoscloud_nic" "api_app" {
  datacenter_id       = ionoscloud_datacenter.taskboard.id
  server_id           = ionoscloud_server.api.id
  lan                 = ionoscloud_lan.app.id
  name                = "app"
  dhcp                = true
  ips                 = ["10.10.1.11"]
  firewall_active     = false
  security_groups_ids = [ionoscloud_nsg.app.id]
}

ionoscloud_server et ionoscloud_vcpu_server acceptent le même argument security_groups_ids pour l'appartenance à l'ensemble des serveurs. Un VDC peut avoir un NSG par défaut, lié avec ionoscloud_datacenter_nsg_selection ; chaque VM nouvellement provisionnée y est ajoutée automatiquement.

1.3 Limites et portée des NSG

Les valeurs par défaut sont de 200 NSG par VDC, 100 règles par NSG, et 10 NSG par VM ou par NIC. Vous ne pouvez pas ajouter des nœuds provenant des pools de nœuds Managed Kubernetes ou des Cubes suspendus en tant que membres. Les membres d'un NSG sont des NIC et des VM, de sorte qu'un NSG se lie aux serveurs situés derrière un équilibreur de charge, et jamais à l'ALB ou au NLB lui-même (section 4).

Le pare-feu basé sur les NIC utilise la ressource ionoscloud_firewall et le drapeau firewall_active sur une NIC. L'utilisation des NSG en parallèle avec un pare-feu basé sur les NIC n'est pas recommandée, c'est pourquoi la NIC ci-dessus définit firewall_active = false.

2. Le Managed Application Load Balancer

Le ALB fonctionne au niveau 7. Chaque ALB nécessite au moins un écouteur, une règle de transfert et un groupe de cibles. Un écouteur accepte les connexions des clients sur une IP et un port ; les règles de transfert déterminent comment les requêtes atteignent les cibles enregistrées.

2.1 Load Balancer et groupe de cibles

resource "ionoscloud_ipblock" "alb" {
  name     = "taskboard-alb-ip"
  location = ionoscloud_datacenter.taskboard.location
  size     = 1
}

resource "ionoscloud_application_loadbalancer" "api" {
  datacenter_id  = ionoscloud_datacenter.taskboard.id
  name           = "taskboard-alb"
  listener_lan   = ionoscloud_lan.public.id
  ips            = [ionoscloud_ipblock.alb.ips[0]]
  target_lan     = ionoscloud_lan.app.id
  lb_private_ips = ["10.10.1.6/24"]
}

resource "ionoscloud_target_group" "api" {
  name             = "taskboard-api"
  algorithm        = "ROUND_ROBIN"
  protocol         = "HTTP"
  protocol_version = "HTTP1"

  targets {
    ip     = "10.10.1.11"
    port   = 80
    weight = 100
  }

  health_check {
    check_interval = 2000
    retries        = 3
  }
  http_health_check {
    path       = "/health"
    method     = "GET"
    match_type = "STATUS_CODE"
    response   = "200"
  }
}

Une ALB publique nécessite des IP publiques réservées par le client sur le LAN de l'écouteur, de sorte que ips provient d'un bloc IP. target_lan est le LAN privé équilibré, et lb_private_ips est l'adresse propre à l'ALB dans ce LAN, avec un masque de sous-réseau. Si vous l'omettez, le système génère une IP avec un sous-réseau /24. Une adresse fixe issue de la plage des services gérés (Unité 2.2, Section 1.3) vous permet d'écrire des règles NSG à son encontre.

Les poids des cibles vont de 0 à 256. Une cible avec un poids de 0 ne reçoit aucun trafic équilibré, mais accepte toujours les connexions persistantes. L'intervalle de vérification d'état est par défaut de 2000 ms avec 3 nouvelles tentatives, et la valeur par défaut de path pour la vérification d'état HTTP est /.

2.2 Règles de transfert et routage basé sur le chemin

resource "ionoscloud_application_loadbalancer_forwardingrule" "http" {
  datacenter_id               = ionoscloud_datacenter.taskboard.id
  application_loadbalancer_id = ionoscloud_application_loadbalancer.api.id
  name                        = "http"
  protocol                    = "HTTP"
  listener_ip                 = ionoscloud_ipblock.alb.ips[0]
  listener_port               = 80

  http_rules {
    name         = "api"
    type         = "FORWARD"
    target_group = ionoscloud_target_group.api.id
    conditions {
      type      = "PATH"
      condition = "STARTS_WITH"
      value     = "/api"
    }
  }

  http_rules {
    name             = "default"
    type             = "STATIC"
    status_code      = 404
    response_message = "Not found"
    content_type     = "text/plain"
  }
}

Une règle FORWARD nécessite un target_group. Les conditions peuvent correspondre à HEADER, PATH, QUERY, METHOD, HOST, COOKIE ou SOURCE_IP, et l'action s'exécute uniquement si toutes les conditions sont remplies. Une règle sans conditions s'applique toujours, de sorte que la règle STATIC renvoie un 404 fixe pour tout autre chemin. Les règles REDIRECT redirigent les clients ailleurs avec les statuts 301, 302, 303, 307 ou 308.

Pour HTTPS, conservez protocol = "HTTP" et transmettez les identifiants de certificats dans server_certificates ; l'ALB met alors fin à la session TLS. Un ALB prend en charge jusqu'à 10 écouteurs, et client_timeout est par défaut de 50 000 ms.

3. Le Managed Network Load Balancer

# ionoscloud_ipblock.nlb: a one-address block, like ionoscloud_ipblock.alb
resource "ionoscloud_networkloadbalancer" "tcp" {
  datacenter_id  = ionoscloud_datacenter.taskboard.id
  name           = "taskboard-nlb"
  listener_lan   = ionoscloud_lan.public.id
  ips            = [ionoscloud_ipblock.nlb.ips[0]]
  target_lan     = ionoscloud_lan.app.id
  lb_private_ips = ["10.10.1.7/24"]
}

resource "ionoscloud_networkloadbalancer_forwardingrule" "ws" {
  datacenter_id          = ionoscloud_datacenter.taskboard.id
  networkloadbalancer_id = ionoscloud_networkloadbalancer.tcp.id
  name                   = "websocket"
  algorithm              = "SOURCE_IP"
  protocol               = "TCP"
  listener_ip            = ionoscloud_ipblock.nlb.ips[0]
  listener_port          = 443

  targets {
    ip     = "10.10.1.11"
    port   = 8443
    weight = 1
    health_check {
      check          = true
      check_interval = 2000
    }
  }
}

Le NLB utilise le même modèle de LAN d'écouteur et de LAN cible, mais ses règles et ses contrôles d'état sont limités au TCP. Les valeurs par défaut des contrôles d'état sont un délai d'attente client de 50 000 ms, un délai d'attente de connexion de 5 000 ms, un délai d'attente cible de 50 000 ms et 3 nouvelles tentatives.

3.1 NLB ou ALB ?

Besoin Choix
Routage par chemin, en-tête, hôte, requête ou cookie ALB
Réponses fixes ou redirections sans serveur d'arrière-plan ALB
Terminaison TLS avec certificats sur l'équilibreur de charge ALB
Tout protocole TCP, décidé uniquement au niveau 4 NLB
Persistance client par adresse IP source NLB avec SOURCE_IP

Si votre logique d'équilibrage de charge nécessite des requêtes HTTP et leurs attributs, utilisez l'ALB. Si les performances de routage sont critiques, maintenez la logique au niveau 4 et routez le trafic TCP via le NLB. TaskBoard utilise l'ALB pour son API REST.

4. Sécurisation des niveaux équilibrés en charge

4.1 Application des règles

Les règles NSG sont associées aux cartes réseau des serveurs du LAN cible, et non à l'équilibreur de charge. Vous sécurisez donc un service placé derrière un ALB depuis le côté cible :

  1. Attribuez à l'ALB une adresse lb_private_ips fixe, par exemple 10.10.1.6.
  2. Autorisez le port du service sur la carte réseau cible uniquement depuis cette adresse (section 1).
  3. Ne fournissez aucune carte réseau publique aux cibles, ou excluez la carte réseau publique du chemin du service.
locals {
  alb_private_ip = "10.10.1.6"
}
# In the ALB:      lb_private_ips = ["${local.alb_private_ip}/24"]
# In the NSG rule: source_ip      = local.alb_private_ip

Une seule valeur locale permet de synchroniser l'adresse de l'ALB et la règle NSG. Dans le laboratoire de cette unité, le serveur API conserve sa carte réseau publique pour SSH ; en production, supprimez-la et accédez au serveur via le VPN (Unité 2.2).

4.2 Trafic sortant des cibles

Ni l'ALB ni le NLB ne prennent en charge la Source NAT (SNAT) : les cibles ne peuvent pas initier de connexions réseau à travers l'équilibreur de charge. Les serveurs situés derrière l'équilibreur de charge qui doivent télécharger des paquets ou appeler des API externes utilisent le Managed NAT Gateway et la route décrite dans l'Unité 2.2. La règle de trafic sortant NSG de la section 1 doit également autoriser ce trafic.

Fiche de référence rapide de l'API

Principaux points de terminaison d'API derrière les ressources de cette unité :

Méthode Point de terminaison Description
POST /datacenters/{datacenterId}/securitygroups Créé par ionoscloud_nsg
POST /datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules Créé par ionoscloud_nsg_firewallrule
PUT /datacenters/{datacenterId}/servers/{serverId}/nics/{nicId}/securitygroups Définit les NSG d'une NIC
POST /datacenters/{datacenterId}/applicationloadbalancers Créé par ionoscloud_application_loadbalancer
POST /targetgroups Créé par ionoscloud_target_group

URL de base : https://api.ionos.com/cloudapi/v6 Authentification : Authorization: Bearer <token>

Atelier de code

Objectif : Déployer un ALB devant l'API de TaskBoard à l'aide de Terraform, attacher un NSG à la NIC d'application du serveur API et vérifier que le trafic HTTP n'atteint l'API que via l'ALB.

Prérequis :

  • Le projet réseau de l'Unité 2.2, appliqué, avec IONOS_TOKEN défini
  • Terraform avec le fournisseur verrouillé comme dans l'Unité 1.2
  • Le serveur API servant du HTTP sur le port 80 (cloud-init de l'Unité 2.1)

Étape 1 : Ajouter un point de contrôle de santé au serveur API

Étendez la configuration cloud du serveur API afin que nginx renvoie 200 pour /health et /api/ (par exemple avec write_files et deux blocs location). Comme user_data ne s'applique qu'aux nouveaux volumes, reconstruisez le serveur :

terraform apply -replace=ionoscloud_server.api -auto-approve | tail -n 1

Sortie attendue :

Apply complete! Resources: ... added, 0 changed, ... destroyed.

Étape 2 : Ajouter le NSG et ses règles

Ajoutez ionoscloud_nsg.app ainsi que les deux règles de la section 1, et définissez firewall_active = false et security_groups_ids sur ionoscloud_nic.api_app (section 1.2).

terraform plan | grep -E "will be (created|updated)"

Sortie attendue :

  # ionoscloud_nic.api_app will be updated in-place
  # ionoscloud_nsg.app will be created
  # ionoscloud_nsg_firewallrule.app_egress will be created
  # ionoscloud_nsg_firewallrule.app_http_from_alb will be created

Étape 3 : Ajouter l'ALB, le groupe de cibles et la règle de transfert

Ajoutez les ressources des sections 2.1 et 2.2, ainsi qu'une sortie :

output "alb_ip" { value = ionoscloud_ipblock.alb.ips[0] }
terraform apply -auto-approve | tail -n 1

Sortie attendue :

Apply complete! Resources: 7 added, 1 changed, 0 destroyed.

Étape 4 : Vérifier l'ALB via l'API

DC=$(terraform output -raw datacenter_id)
curl -s -H "Authorization: Bearer $IONOS_TOKEN" \
  "https://api.ionos.com/cloudapi/v6/datacenters/$DC/applicationloadbalancers?depth=1" \
  | jq -r '.items[] | "\(.properties.name) \(.metadata.state)"'

Sortie attendue :

taskboard-alb AVAILABLE

Étape 5 : Vérifier le routage via l'ALB

ALB=$(terraform output -raw alb_ip)
curl -s -o /dev/null -w "%{http_code}\n" "http://$ALB/api/"
curl -s -o /dev/null -w "%{http_code}\n" "http://$ALB/other"

Sortie attendue :

200
404

Étape 6 : Vérifier l'isolation au sein du LAN de l'application

ssh -J root@"$(terraform output -raw api_public_ip)" root@10.10.1.21 \
  'curl -s --max-time 5 -o /dev/null -w "%{http_code}\n" http://10.10.1.11/api/ || echo blocked'

Sortie attendue :

000
blocked

Le worker se trouve sur le même LAN, mais le NSG sur la NIC d'application du serveur API n'autorise le port 80 que depuis l'adresse 10.10.1.6 de l'ALB.

Liste de contrôle de validation :

  • [ ] L'ALB est AVAILABLE avec l'IP publique réservée
  • [ ] /api/ renvoie 200 via l'ALB et les autres chemins renvoient le 404 statique
  • [ ] Le worker ne peut pas atteindre le port 80 du serveur API directement
  • [ ] terraform plan n'affiche aucune modification après l'application

Nettoyage :

terraform destroy -auto-approve

Erreurs courantes

Erreurs de développement à éviter concernant le sujet de cette unité :

  1. Tout le trafic est bloqué après l'attachement d'un NSG

    • Problème : Dès que le NSG est attaché, le serveur cesse de répondre et ne peut plus atteindre la passerelle NAT ni la base de données.
    • Cause : Les NSG refusent tout trafic non autorisé par une règle, dans les deux sens.
    • Correction : Ajoutez des règles EGRESS explicites pour le trafic sortant dont le serveur a besoin, et des règles INGRESS pour chaque adresse et port client.
  2. S'attendre à ce que le NSG protège l'équilibreur de charge

    • Problème : Vous attachez un NSG à l'ALB dans un document de conception, mais le plan Terraform n'a nulle part où le placer.
    • Cause : Les membres d'un NSG sont des NIC et des VM. L'écouteur de l'équilibreur de charge n'est pas un membre.
    • Correction : Filtrez sur les NIC cibles, avec des règles qui n'autorisent que l'adresse lb_private_ips fixe de l'équilibreur de charge (section 4.1).
  3. Les vérifications d'état marquent toutes les cibles comme indisponibles

    • Problème : L'ALB renvoie des erreurs bien que le serveur API soit en fonctionnement.
    • Cause : La vérification d'état HTTP demande un chemin que l'application ne sert pas, ou le NSG bloque la vérification d'état provenant de l'adresse privée de l'ALB.
    • Correction : Pointez http_health_check.path vers un point de terminaison qui renvoie le response configuré, et autorisez l'IP privée de l'ALB sur le port du service.

Résumé

Vous pouvez désormais placer l'API de TaskBoard derrière un équilibreur de charge et la sécuriser sous forme de code. Les NSG contiennent des règles à état, par défaut en mode refus, que vous attachez aux serveurs ou aux NIC. L'ALB connecte un LAN d'écouteur public à un LAN cible privé, achemine les requêtes HTTP par chemin vers des groupes de cibles avec des vérifications d'état, et peut renvoyer des réponses fixes. Le NLB prend en charge l'équilibrage TCP uniquement, et la frontière de sécurité se situe toujours sur les NIC des cibles.

Points clés :

  • Les règles NSG n'autorisent que le trafic ; tout le reste est bloqué dans les deux sens, et les réponses sont autorisées (à état)
  • Les membres des NSG sont des NIC et des VM ; n'utilisez pas les NSG en parallèle avec le pare-feu basé sur les NIC
  • Un ALB nécessite un écouteur, une règle de transfert et un groupe de cibles ; les écouteurs publics nécessitent des IP réservées
  • Utilisez l'ALB pour l'acheminement HTTP et la terminaison TLS, et le NLB pour l'équilibrage TCP de niveau 4
  • Aucun des deux équilibreurs de charge ne prend en charge le SNAT ; les cibles utilisent la passerelle NAT pour le trafic sortant

Terminologie importante :

  • Network Security Group (NSG) : Un ensemble de règles d'autorisation à état appliquées aux NIC ou aux VM membres d'un VDC
  • LAN d'écouteur : Le LAN sur lequel un équilibreur de charge accepte les connexions des clients
  • LAN cible : Le LAN privé auquel un équilibreur de charge accède à ses cibles via lb_private_ips
  • Groupe de cibles : Un ensemble réutilisable de cibles ALB avec un algorithme et des vérifications d'état
  • Règle de transfert : La configuration de l'écouteur qui associe une IP et un port à des cibles, avec des règles HTTP sur un ALB

Prochaines étapes

Continuer l'apprentissage : Unité 2.4 : Provisionnement du stockage en tant que code

Sujets connexes :