AWS Route 53

Service DNS hautement disponible et évolutif pour diriger les utilisateurs vers vos applications avec un routage intelligent et des contrôles de santé fiables.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que Route 53 ?

Imaginez Internet comme une immense ville avec des millions de bâtiments (les serveurs web). Pour visiter un site web, vous utilisez son nom (comme "google.com"), mais les ordinateurs ont besoin de l'adresse exacte (une adresse IP comme "142.250.74.110").

AWS Route 53 fonctionne comme un service d'annuaire téléphonique ultra-sophistiqué (ou GPS) pour Internet. Quand quelqu'un tape le nom de votre site web, Route 53 le traduit instantanément en adresse IP pour que les navigateurs sachent où aller.

Pourquoi "Route 53" ?

Le nom vient du port TCP/IP 53, qui est le port standard utilisé par les serveurs DNS (Domain Name System). C'est un petit clin d'œil technique, comme la "Route 66" du web !

Ce que fait Route 53

Gestion de domaines

Vous permet d'acheter et de gérer des noms de domaine comme "votre-entreprise.com" directement depuis votre compte AWS.

Routage intelligent

Dirige les visiteurs vers le serveur le plus proche ou le plus rapide, améliorant ainsi leur expérience d'utilisation de votre site ou application.

En résumé, Route 53 est un service essentiel qui assure que les utilisateurs peuvent trouver et accéder à vos applications web de manière fiable, rapide et sécurisée, où qu'ils se trouvent dans le monde.

Pour les développeurs

Fonctionnement technique

AWS Route 53 est un service DNS (Domain Name System) hautement disponible et évolutif qui combine l'enregistrement de domaines, la résolution DNS, le routage du trafic et la surveillance de l'état de santé.

Composants principaux

Zones hébergées

Une zone hébergée est un conteneur pour les enregistrements DNS qui définit comment le trafic est acheminé pour un domaine spécifique (comme example.com) et ses sous-domaines.

Zones publiques : Résolvent les noms sur l'internet public
Zones privées : Résolvent les noms uniquement au sein des VPC AWS spécifiés
Serveurs de noms : Chaque zone reçoit un ensemble de 4 serveurs de noms
NS Records : Servent à déléguer l'autorité pour le domaine à Route 53
SOA Record : Contient des métadonnées administratives sur la zone

Enregistrements (Records)

Les enregistrements DNS contiennent les informations nécessaires pour résoudre les noms de domaine vers des ressources spécifiques.

A/AAAA : Associe un domaine à une adresse IPv4/IPv6
CNAME : Crée un alias d'un nom vers un autre nom
MX : Définit les serveurs de messagerie pour le domaine
TXT : Stocke des informations textuelles (souvent pour la vérification)
Alias : Type spécifique à Route 53 pour pointer vers des ressources AWS
CAA : Spécifie quelles autorités de certification sont autorisées à délivrer des certificats

Politiques de routage

Les politiques de routage déterminent comment Route 53 répond aux requêtes DNS, offrant diverses stratégies pour diriger le trafic.

Simple : Routage de base vers une seule ressource
Pondéré : Distribution selon des proportions définies (ex: 80% vers v1, 20% vers v2)
Latence : Dirige les utilisateurs vers la région AWS avec la latence la plus faible
Géolocalisation : Achemine le trafic en fonction de l'emplacement géographique des utilisateurs
Géoproximité : Routage basé sur la distance géographique réelle (avec biais ajustable)
Basculement (Failover) : Redirection vers un système de secours en cas de défaillance
Multi-valeur : Renvoie plusieurs valeurs saines en réponse aux requêtes DNS

Contrôles de santé (Health Checks)

Les contrôles de santé surveillent la disponibilité et les performances des ressources pour garantir que le trafic est uniquement dirigé vers des points de terminaison sains.

Contrôles d'endpoint : Vérifient l'état d'un serveur web ou autre ressource
Contrôles basés sur CloudWatch : Utilisent les métriques CloudWatch
Contrôles calculés : Combinent les résultats d'autres contrôles de santé
Intervalles : Vérifications toutes les 10 ou 30 secondes
Seuils : Nombre d'échecs consécutifs avant qu'un endpoint soit considéré comme défaillant
Intégration SNS : Notifications en cas de changement d'état

Route 53 Resolver

Service de résolution DNS récursif qui permet des requêtes DNS entre les VPC AWS et les réseaux sur site.

Endpoints entrants : Permettent aux réseaux on-premise de résoudre les DNS dans AWS
Endpoints sortants : Permettent aux VPC AWS de résoudre les DNS on-premise
Règles de transfert : Déterminent quelles requêtes DNS sont acheminées vers les réseaux connectés
Resolver DNS Firewall : Filtrage et blocage des requêtes DNS malveillantes

Implémentation technique

Voyons comment configurer et utiliser Route 53 dans différents scénarios avec des exemples de code.

1. Création d'une zone hébergée

Configuration d'une zone hébergée pour un domaine avec le SDK AWS :

Création d'une zone hébergée

// Création d'une zone hébergée publique avec AWS SDK v3
const { Route53Client, CreateHostedZoneCommand } = require("@aws-sdk/client-route-53");

const client = new Route53Client({ region: "us-east-1" }); // Route 53 est un service global

async function createHostedZone() {
  try {
    const command = new CreateHostedZoneCommand({
      Name: "example.com", // Domaine
      CallerReference: `hostedzone-${Date.now()}`, // Identifiant unique
      HostedZoneConfig: {
        Comment: "Zone hébergée pour example.com",
        PrivateZone: false // Zone publique
      }
    });

    const response = await client.send(command);
    console.log("Zone hébergée créée avec succès:", response);
    
    // Afficher les serveurs de noms attribués
    console.log("Serveurs de noms:", response.DelegationSet.NameServers);
    
    return response;
  } catch (error) {
    console.error("Erreur lors de la création de la zone hébergée:", error);
    throw error;
  }
}

2. Ajout d'enregistrements DNS

Ajout de différents types d'enregistrements DNS à une zone hébergée :

Ajout d'enregistrements DNS

// Ajout d'enregistrements DNS avec AWS SDK v3
const { Route53Client, ChangeResourceRecordSetsCommand, ResourceRecordSet } = require("@aws-sdk/client-route-53");

const client = new Route53Client({ region: "us-east-1" });

async function addDnsRecords(hostedZoneId) {
  try {
    // Création de plusieurs enregistrements DNS en une seule transaction
    const command = new ChangeResourceRecordSetsCommand({
      HostedZoneId: hostedZoneId,
      ChangeBatch: {
        Comment: "Ajout d'enregistrements DNS pour example.com",
        Changes: [
          // Enregistrement A pour le domaine apex (racine)
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "example.com",
              Type: "A",
              TTL: 300,
              ResourceRecords: [
                { Value: "192.0.2.123" } // Adresse IP fictive
              ]
            }
          },
          // Enregistrement CNAME pour le sous-domaine www
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "www.example.com",
              Type: "CNAME",
              TTL: 300,
              ResourceRecords: [
                { Value: "example.com" }
              ]
            }
          },
          // Enregistrement MX pour le courrier électronique
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "example.com",
              Type: "MX",
              TTL: 3600,
              ResourceRecords: [
                { Value: "10 mail.example.com" }
              ]
            }
          },
          // Enregistrement TXT pour la vérification du domaine
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "example.com",
              Type: "TXT",
              TTL: 300,
              ResourceRecords: [
                { Value: "\"v=spf1 include:_spf.example.com ~all\"" }
              ]
            }
          }
        ]
      }
    });

    const response = await client.send(command);
    console.log("Enregistrements DNS ajoutés avec succès:", response);
    return response;
  } catch (error) {
    console.error("Erreur lors de l'ajout des enregistrements DNS:", error);
    throw error;
  }
}

3. Configuration d'un enregistrement alias pour CloudFront

Création d'un enregistrement alias pointant vers une distribution CloudFront :

Configuration d'un enregistrement alias

// Création d'un enregistrement alias pour CloudFront avec AWS SDK v3
const { Route53Client, ChangeResourceRecordSetsCommand } = require("@aws-sdk/client-route-53");

const client = new Route53Client({ region: "us-east-1" });

async function createCloudFrontAlias(hostedZoneId, domainName, distributionDomainName) {
  try {
    const command = new ChangeResourceRecordSetsCommand({
      HostedZoneId: hostedZoneId,
      ChangeBatch: {
        Comment: "Création d'un enregistrement alias pour CloudFront",
        Changes: [
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: domainName, // ex: "example.com"
              Type: "A",
              AliasTarget: {
                HostedZoneId: "Z2FDTNDATAQYW2", // ID de zone fixe pour CloudFront
                DNSName: distributionDomainName, // ex: "d123456abcdef8.cloudfront.net"
                EvaluateTargetHealth: false
              }
            }
          }
        ]
      }
    });

    const response = await client.send(command);
    console.log("Enregistrement alias créé avec succès:", response);
    return response;
  } catch (error) {
    console.error("Erreur lors de la création de l'enregistrement alias:", error);
    throw error;
  }
}

4. Configuration du routage pondéré

Mise en place d'une politique de routage pondéré pour diriger le trafic vers différentes régions :

Configuration du routage pondéré

// Configuration d'une politique de routage pondéré avec AWS SDK v3
const { Route53Client, ChangeResourceRecordSetsCommand } = require("@aws-sdk/client-route-53");

const client = new Route53Client({ region: "us-east-1" });

async function createWeightedRoutingPolicy(hostedZoneId) {
  try {
    const command = new ChangeResourceRecordSetsCommand({
      HostedZoneId: hostedZoneId,
      ChangeBatch: {
        Comment: "Configuration d'une politique de routage pondéré",
        Changes: [
          // Région principale (75% du trafic)
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "api.example.com",
              Type: "A",
              SetIdentifier: "Primary Region",
              Weight: 75,
              TTL: 60,
              ResourceRecords: [
                { Value: "203.0.113.100" } // Adresse IP fictive de la région principale
              ]
            }
          },
          // Région secondaire (25% du trafic)
          {
            Action: "CREATE",
            ResourceRecordSet: {
              Name: "api.example.com",
              Type: "A",
              SetIdentifier: "Secondary Region",
              Weight: 25,
              TTL: 60,
              ResourceRecords: [
                { Value: "203.0.113.200" } // Adresse IP fictive de la région secondaire
              ]
            }
          }
        ]
      }
    });

    const response = await client.send(command);
    console.log("Politique de routage pondéré créée avec succès:", response);
    return response;
  } catch (error) {
    console.error("Erreur lors de la création de la politique de routage:", error);
    throw error;
  }
}

5. Configuration complète avec AWS CDK

Exemple complet d'infrastructure multi-région avec contrôles de santé et politique de basculement :

Configuration Route 53 avec AWS CDK

// Configuration de Route 53 avec AWS CDK (TypeScript)
import * as cdk from 'aws-cdk-lib';
import * as route53 from 'aws-cdk-lib/aws-route53';
import * as targets from 'aws-cdk-lib/aws-route53-targets';
import * as ec2 from 'aws-cdk-lib/aws-ec2';
import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
import { Construct } from 'constructs';

export class MultiRegionRoutingStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // Récupérer une zone hébergée existante
    const hostedZone = route53.HostedZone.fromLookup(this, 'MyHostedZone', {
      domainName: 'example.com'
    });

    // Créer un contrôle de santé pour surveiller un point de terminaison
    const primaryHealthCheck = new route53.HealthCheck(this, 'PrimaryHealthCheck', {
      type: route53.HealthCheckType.HTTP,
      resourcePath: '/health',
      fullyQualifiedDomainName: 'primary-endpoint.example.com',
      port: 80,
      requestInterval: cdk.Duration.seconds(30),
      failureThreshold: 3,
      healthCheckName: 'Primary Region Health Check'
    });

    const secondaryHealthCheck = new route53.HealthCheck(this, 'SecondaryHealthCheck', {
      type: route53.HealthCheckType.HTTP,
      resourcePath: '/health',
      fullyQualifiedDomainName: 'secondary-endpoint.example.com',
      port: 80,
      requestInterval: cdk.Duration.seconds(30),
      failureThreshold: 3,
      healthCheckName: 'Secondary Region Health Check'
    });

    // Création d'un enregistrement de basculement (failover)
    const primaryRecord = new route53.RecordSet(this, 'PrimaryRecord', {
      zone: hostedZone,
      recordName: 'api.example.com',
      recordType: route53.RecordType.A,
      ttl: cdk.Duration.seconds(60),
      target: route53.RecordTarget.fromIpAddresses('203.0.113.100'),
      failover: route53.FailoverRecordSetConfig.PRIMARY,
      healthCheck: primaryHealthCheck
    });

    const secondaryRecord = new route53.RecordSet(this, 'SecondaryRecord', {
      zone: hostedZone,
      recordName: 'api.example.com',
      recordType: route53.RecordType.A,
      ttl: cdk.Duration.seconds(60),
      target: route53.RecordTarget.fromIpAddresses('203.0.113.200'),
      failover: route53.FailoverRecordSetConfig.SECONDARY,
      healthCheck: secondaryHealthCheck
    });

    // Ajout d'un enregistrement basé sur la latence pour le site web principal
    // Pour diriger les utilisateurs vers la région AWS la plus proche
    const usEastRecord = new route53.RecordSet(this, 'UsEastRecord', {
      zone: hostedZone,
      recordName: 'www.example.com',
      recordType: route53.RecordType.A,
      ttl: cdk.Duration.seconds(60),
      target: route53.RecordTarget.fromIpAddresses('203.0.113.10'),
      region: 'us-east-1',
      setIdentifier: 'us-east-1'
    });

    const euWestRecord = new route53.RecordSet(this, 'EuWestRecord', {
      zone: hostedZone,
      recordName: 'www.example.com',
      recordType: route53.RecordType.A,
      ttl: cdk.Duration.seconds(60),
      target: route53.RecordTarget.fromIpAddresses('203.0.113.20'),
      region: 'eu-west-1',
      setIdentifier: 'eu-west-1'
    });

    const apSoutheastRecord = new route53.RecordSet(this, 'ApSoutheastRecord', {
      zone: hostedZone,
      recordName: 'www.example.com',
      recordType: route53.RecordType.A,
      ttl: cdk.Duration.seconds(60),
      target: route53.RecordTarget.fromIpAddresses('203.0.113.30'),
      region: 'ap-southeast-1',
      setIdentifier: 'ap-southeast-1'
    });

    // Exporter les valeurs importantes
    new cdk.CfnOutput(this, 'HostedZoneId', {
      value: hostedZone.hostedZoneId
    });
    
    new cdk.CfnOutput(this, 'PrimaryHealthCheckId', {
      value: primaryHealthCheck.healthCheckId
    });
  }
}

Intégration avec d'autres services AWS

Route 53 s'intègre de manière transparente avec de nombreux services AWS pour créer des architectures robustes :

S3 : Enregistrements alias vers des sites web hébergés sur S3
CloudFront : Distribution de contenu via CDN avec alias Route 53
ELB : Équilibrage de charge avec vérifications de santé coordonnées
EC2 : Résolution DNS pour les instances, y compris Auto Scaling
API Gateway : Point d'entrée API avec nom de domaine personnalisé
ACM : Gestion automatisée des certificats SSL/TLS
CloudWatch : Surveillance et alerte sur les métriques DNS
AWS Global Accelerator : Routage global optimisé pour les applications multi-région

Avantages techniques

Haute disponibilité : SLA de 100% pour la résolution DNS, avec redondance mondiale
Évolutivité automatique : Gère des volumes massifs de requêtes DNS sans configuration
Latence faible : Anycast routing avec points de présence mondiaux
Sécurité DNS : Support DNSSEC pour l'authentification des réponses DNS
Routage complexe : Politiques flexibles adaptées à diverses architectures
Surveillance intégrée : Contrôles de santé et métriques détaillées
API complète : Automatisation de toutes les opérations DNS

Applications concrètes

Cas d'usage

Haute disponibilité et reprise après sinistre

Configuration de politiques de basculement (failover) pour rediriger automatiquement le trafic vers des systèmes de secours en cas de défaillance. Les contrôles de santé surveillent activement les endpoints et déclenchent la bascule quand nécessaire.

Applications multi-région

Utilisation des politiques de routage basé sur la latence ou la géolocalisation pour diriger les utilisateurs vers la région AWS la plus proche, réduisant ainsi les temps de réponse et améliorant l'expérience utilisateur globale.

Tests A/B et déploiement bleu/vert

Implémentation de politiques de routage pondéré pour diriger des pourcentages spécifiques du trafic vers différentes versions d'une application. Idéal pour tester de nouvelles fonctionnalités avec un sous-ensemble d'utilisateurs avant un déploiement complet.

DNS privé pour réseaux hybrides

Utilisation de Route 53 Resolver pour la résolution DNS fluide entre AWS et les infrastructures sur site, permettant aux applications de communiquer de manière transparente à travers les frontières du réseau avec des noms conviviaux.

Architectures avancées

Architecture globale avec failback automatique

Une architecture qui utilise les contrôles de santé Route 53 pour surveiller continuellement la disponibilité de la région principale et basculer automatiquement vers la région secondaire en cas de défaillance. Une fois la région principale restaurée, le trafic y est redirigé automatiquement.

Composants clés : Route 53 avec politiques de failover, contrôles de santé personnalisés, alarmes CloudWatch, fonctions Lambda pour orchestrer la restauration automatique.

Architecture multi-niveau avec isolation des défaillances

Une architecture qui utilise des politiques de routage imbriquées pour isoler les défaillances au niveau le plus spécifique possible. Par exemple, une politique géographique au niveau supérieur dirige les utilisateurs vers leur région, puis une politique de latence détermine le meilleur datacenter, suivie d'une politique de basculement pour la résilience locale.

Composants clés : Route 53 avec politiques de routage en cascade, contrôles de santé à plusieurs niveaux, déploiements multi-AZ et multi-région.

DNS intelligent avec modification dynamique

Une architecture qui ajuste dynamiquement les politiques de routage DNS en réponse aux conditions du système, comme la charge, la latence ou d'autres métriques. Par exemple, rediriger plus de trafic vers des régions sous-utilisées ou éviter celles qui montrent des signes de stress.

Composants clés : Route 53 API, Lambda pour l'automatisation, CloudWatch pour les métriques, EventBridge pour l'orchestration des changements.

Ressources complémentaires

Toutes les compétences

Technologies associées

CloudFront

AWS S3

AWS EC2

API Gateway

AWS Lambda

Explorer toutes mes compétences