Configurer le protocole TLS authentifié côté backend

Preview

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Cette page explique comment configurer le protocole TLS authentifié par le backend, également appelé authentification du backend, à l'aide de certificats autogérés pour les équilibreurs de charge d'application externes globaux.

Pour configurer le TLS authentifié côté backend, procédez comme suit:

• Créez une ressource de configuration de confiance composée de certificats racine et intermédiaires.
• Créez une ressource de configuration d'authentification de backend qui fait référence à la configuration de confiance.
• Associez la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge.

Avant de commencer

• Consultez la présentation du TLS authentifié côté backend et du mTLS côté backend.
• Consultez Gérer les configurations de confiance.

• Si vous souhaitez suivre les instructions de ce guide à l'aide de Google Cloud CLI, vous devez l'installer. Vous trouverez des commandes liées à l'équilibrage de charge dans la documentation de référence de l'API et de gcloud CLI.

  Si vous n'avez pas encore utilisé gcloud CLI, exécutez d'abord la commande gcloud init pour vous authentifier.

• Activez les API suivantes: l'API Compute Engine, l'API Certificate Manager, la sécurité réseau et l'API Network Services. Pour en savoir plus, consultez Activer des API.

• Configurez un équilibreur de charge d'application externe global avec l'un des backends compatibles suivants:

  • Backends de groupe d'instances de VM
  • NEG de connectivité hybride
  • NEG zonaux

Autorisations

Cette section liste les autorisations requises pour configurer le TLS authentifié côté backend.

Opération	Autorisation
Créer une configuration de confiance	certificatemanager.trustconfigs.create sur le projet Google Cloud cible
Créer une ressource de configuration d'authentification de backend	certificatemanager.certs.use sur le certificat cible certificatemanager.trustconfigs.use sur la configuration de confiance cible networksecurity.backendauthenticationconfigs.create sur le projet Google Cloud cible
Associer la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge	compute.backendservice.update sur le service de backend cible networksecurity.backendauthenticationconfigs.use sur la ressource de configuration d'authentification de backend cible

Vue d'ensemble de la configuration

Les sections suivantes décrivent les étapes à suivre pour configurer le protocole TLS authentifié côté backend en fonction de l'architecture illustrée dans le schéma suivant:

Composants TLS authentifiés du backend (cliquez pour agrandir).

Créer les certificats racine et intermédiaires

Remarque :

Si vous disposez déjà de certificats à importer dans le magasin de confiance, vous pouvez ignorer cette étape et passer à l'étape Mettre en forme les certificats.

Cette section utilise la bibliothèque OpenSSL pour créer le certificat racine (ancre de confiance) et le certificat intermédiaire.

Un certificat racine se trouve au sommet de la chaîne de certificats. Un certificat intermédiaire fait partie de la chaîne de confiance qui remonte au certificat racine. Le certificat intermédiaire est signé de manière cryptographique par le certificat racine. Lorsque l'équilibreur de charge reçoit un certificat de serveur, il le valide en établissant une chaîne de confiance à partir du certificat de serveur jusqu'à l'ancre de confiance configurée.

Utilisez les commandes suivantes pour créer les certificats racine et intermédiaires.

1. Créez un fichier de configuration OpenSSL.

   Dans l'exemple suivant, le fichier de configuration (example.cnf) contient la section [ca_exts], qui spécifie les extensions X.509 qui marquent le certificat comme adapté à une autorité de certification. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez la section Exigences concernant les certificats.

   cat > example.cnf << EOF
   [req]
   distinguished_name = empty_distinguished_name
   
   [empty_distinguished_name]
   # Kept empty to allow setting via -subj command-line argument.
   
   [ca_exts]
   basicConstraints=critical,CA:TRUE
   keyUsage=keyCertSign
   extendedKeyUsage=serverAuth
   
   EOF
   

2. Créez un certificat racine X.509 autosigné (root.cert). Le certificat racine est autosigné avec sa propre clé privée (root.key).

   openssl req -x509 \
       -new -sha256 -newkey rsa:2048 -nodes \
       -days 3650 -subj '/CN=root' \
       -config example.cnf \
       -extensions ca_exts \
       -keyout root.key -out root.cert
   

3. Créez la requête de signature de certificat (CSR) int.req pour le certificat intermédiaire.

   openssl req -new \
       -sha256 -newkey rsa:2048 -nodes \
       -subj '/CN=int' \
       -config example.cnf \
       -extensions ca_exts \
       -keyout int.key -out int.req
   

4. Signez la requête de signature de certificat pour créer le certificat intermédiaire X.509 (int.cert). La requête de signature de certificat est signée à l'aide du certificat racine.

   openssl x509 -req \
       -CAkey root.key -CA root.cert \
       -set_serial 1 \
       -days 3650 \
       -extfile example.cnf \
       -extensions ca_exts \
       -in int.req -out int.cert
   

Mettre en forme les certificats

Pour inclure de nouveaux certificats ou des certificats existants dans un truststore, définissez une mise en forme de ces certificats sur une seule ligne et stockez-les dans des variables d'environnement afin qu'ils puissent être référencés par le fichier YAML de configuration de confiance.

export ROOT_CERT=$(cat root.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

export INTERMEDIATE_CERT=$(cat int.cert | sed 's/^[ ]*//g' | tr '\n' $ | sed 's/\$/\\n/g')

Créer une ressource de configuration de confiance

Une configuration de confiance est une ressource qui représente votre configuration d'infrastructure à clé publique (PKI) dans le gestionnaire de certificats.

Pour créer une ressource de configuration de confiance, procédez comme suit:

Console

1. Dans la console Google Cloud, accédez à la page Gestionnaire de certificats.

   Accéder au Gestionnaire de certificats

2. Dans l'onglet Configurations d'approbation, cliquez sur Ajouter une configuration d'approbation.

3. Attribuez un nom à la configuration.

4. Dans Emplacement, sélectionnez Mondial. L'emplacement indique l'emplacement où la ressource de configuration de confiance est stockée. Pour les équilibreurs de charge d'application externes globaux, vous devez créer une ressource de configuration de confiance globale.

5. Dans la section Truststore (Truststore), cliquez sur Add trust anchor (Ajouter une ancre de confiance) et importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat.

6. Cliquez sur Ajouter.

7. Dans la section Truststore (Truststore), cliquez sur Add intermediate CA (Ajouter une autorité de certification intermédiaire) et importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat. Cette étape vous permet d'ajouter un autre niveau de confiance entre le certificat racine et votre certificat de serveur.

8. Cliquez sur Add (Ajouter) pour ajouter l'autorité de certification intermédiaire.

9. Pour ajouter le certificat à la liste d'autorisation, cliquez sur Ajouter.

10. Cliquez sur Créer.

Vérifiez que la nouvelle ressource de configuration de confiance apparaît dans la liste des configurations.

gcloud

1. Créez un fichier YAML de configuration de confiance (trust_config.yaml) qui spécifie les paramètres de configuration de confiance. Cet exemple de ressource de configuration de confiance contient un truststore avec une ancre de confiance et un certificat intermédiaire. Cet exemple de ressource de configuration de confiance lit le contenu du certificat à partir des variables d'environnement créées à l'étape précédente, Mettre en forme les certificats.

   cat << EOF > trust_config.yaml
   trustStores:
   - trustAnchors:
     - pemCertificate: "${ROOT_CERT}"
     intermediateCas:
     - pemCertificate: "${INTERMEDIATE_CERT}"
   EOF
   

   Pour créer un truststore avec d'autres ancres de confiance ou d'autres certificats CA intermédiaires, ajoutez des lignes pemCertificate dans la section appropriée.

2. Pour importer le fichier YAML de configuration de confiance, utilisez la commande gcloud certificate-manager trust-configs import:

   Pour les équilibreurs de charge d'application externes globaux, spécifiez global comme emplacement de stockage de la ressource de configuration de confiance.

   gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME  \
       --source=trust_config.yaml \
       --location=global
   

   Remplacez les éléments suivants :

   • TRUST_CONFIG_NAME : nom de la ressource de configuration de confiance

Créer une ressource de configuration d'authentification de backend

Pour créer une ressource de configuration d'authentification du backend (BackendAuthenticationConfig), procédez comme suit :

Console

1. Dans la console Google Cloud, accédez à la page Authentication Configuration (Configuration de l'authentification).

   Accéder à la page "Configuration de l'authentification"

2. Dans l'onglet Authentification backend, cliquez sur Créer.
3. Saisissez un nom pour la ressource de configuration d'authentification de backend.
4. Facultatif: sélectionnez les racines publiques de confiance.
5. Sélectionnez la ressource de configuration de confiance que vous avez créée précédemment.
6. Cliquez sur Créer.

Vérifiez que la ressource "Configuration de l'authentification du backend" s'affiche.

gcloud

1. Créez un fichier YAML qui spécifie de manière déclarative les différents attributs de la ressource de configuration de l'authentification du backend.

   cat << EOF > BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml
   name: projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
   trustConfig: projects/PROJECT_ID/locations/global/trustConfigs/TRUST_CONFIG_NAME
   wellKnownRoots: PUBLIC_ROOTS
   EOF
   

   Remplacez les éléments suivants :

   • BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME : nom du fichier YAML dans lequel la ressource de configuration d'authentification de backend est définie.
   • PROJECT_ID: ID de votre projet Google Cloud
   • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration d'authentification de backend
   • TRUST_CONFIG_NAME: nom de la ressource de configuration de confiance que vous avez créée précédemment.

2. Pour importer la ressource de configuration de l'authentification du backend, utilisez la commande gcloud beta network-security backend-authentication-configs import:

   gcloud beta network-security backend-authentication-configs import BACKEND_AUTH_CONFIG_NAME \
      --source=BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml \
      --location=global
   

   Remplacez les éléments suivants :

   • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration de l'authentification du backend

   • BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME : nom du fichier YAML dans lequel la ressource de configuration de l'authentification du backend est définie.

Associer la ressource de configuration de l'authentification de backend au service de backend de l'équilibreur de charge

Pour associer la ressource de configuration d'authentification de backend (BackendAuthenticationConfig) au service de backend de l'équilibreur de charge, procédez comme suit :

Console

1. Dans Google Cloud Console, accédez à la page Équilibrage de charge.

   Accéder à la page "Équilibrage de charge"

2. Dans l'onglet Backends, sélectionnez le service de backend pour lequel vous devez activer le TLS authentifié et le mTLS de backend.

3. Cliquez sur Modifier ().

4. Développez la section Configurations avancées.

5. Dans la section Authentification du backend, cochez la case Activer.

6. Facultatif: spécifiez le nom d'hôte SNI et les SAN acceptés pour valider le certificat du backend.

7. Pour associer la ressource de configuration de l'authentification du backend au service de backend, dans la liste Configuration de l'authentification du backend, sélectionnez la ressource de configuration de l'authentification du backend.

8. Cliquez sur Continuer.

9. Pour mettre à jour les paramètres du service de backend, cliquez sur Mettre à jour.

gcloud

1. Pour répertorier toutes les ressources de service de backend de votre projet, exécutez la commande gcloud compute backend-services list.

   gcloud compute backend-services list
   

   Notez le nom du service de backend auquel associer la ressource BackendAuthenticationConfig. Ce nom sera appelé BACKEND_SERVICE_NAME dans les étapes suivantes.

2. Pour exporter la configuration du service de backend vers un fichier, utilisez la commande gcloud beta compute backend-services export.

   gcloud beta compute backend-services export BACKEND_SERVICE_NAME \
       --destination=BACKEND_SERVICE_FILENAME.yaml \
       --global
   

   Remplacez les éléments suivants :

   • BACKEND_SERVICE_NAME : Nom du service de backend.
   • BACKEND_SERVICE_FILENAME: nom et chemin d'accès à un fichier YAML dans lequel la configuration du service backend est exportée

3. Mettez à jour l'attribut tlsSettings du service de backend en le pointant vers la ressource de configuration de l'authentification de backend. En outre, vous pouvez configurer le nom d'hôte SNI et les SAN acceptés sur le service de backend pour valider le certificat de backend.

     cat << EOF >> BACKEND_SERVICE_FILENAME.yaml
     tlsSettings:
       authenticationConfig: //networksecurity.googleapis.com/projects/PROJECT_ID/locations/global/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
       sni: examplepetstore.com
       subjectAltNames:
       - dnsName: examplepetstore.com
       - dnsName: api.examplepetstore.com
     EOF
     

   Les valeurs SNI et SAN de la déclaration YAML précédente ne sont fournies qu'à titre d'exemple. Vous pouvez les remplacer par des valeurs réelles pertinentes pour votre configuration.

   Remplacez les éléments suivants :

   • BACKEND_SERVICE_FILENAME: nom du fichier YAML dans lequel la configuration du service backend est exportée

   • PROJECT_ID : ID de votre projet Google Cloud

   • BACKEND_AUTH_CONFIG_NAME: nom de la ressource de configuration de l'authentification du backend

4. Pour importer la configuration du service de backend mise à jour à partir d'un fichier, utilisez la commande gcloud beta compute backend-services import.

   gcloud beta compute backend-services import BACKEND_SERVICE_NAME \
       --source=BACKEND_SERVICE_FILENAME.yaml \
       --global
   

   Remplacez les éléments suivants :

   • BACKEND_SERVICE_NAME : Nom du service de backend.
   • BACKEND_SERVICE_FILENAME: nom du fichier YAML de configuration du service de backend

Créer un certificat de serveur backend

Cette section fournit une option de configuration supplémentaire pour créer un certificat de serveur (d'entité finale) signé par le certificat intermédiaire, qui fait partie de la configuration de confiance. Cela garantit qu'une chaîne de confiance peut être établie à partir du certificat du serveur jusqu'à l'ancre de confiance.

Si vous avez déjà créé une ressource de configuration de confiance contenant un certificat intermédiaire, procédez comme suit:

1. Créez un fichier de configuration pour générer la CSR du certificat de serveur.

   Le fichier de configuration suivant (server.config) contient la section [extension_requirements], qui spécifie les extensions X.509 à inclure dans la CSR. Pour en savoir plus sur les exigences concernant les certificats de serveur, consultez la section Exigences concernant les certificats.

   cat > server.config << EOF
   [req]
   default_bits              = 2048
   req_extensions            = extension_requirements
   distinguished_name        = dn_requirements
   prompt                    = no
   
   [extension_requirements]
   basicConstraints          = critical, CA:FALSE
   keyUsage                  = critical, nonRepudiation, digitalSignature, keyEncipherment
   extendedKeyUsage          = serverAuth
   subjectAltName            = @alt_names
   
   [alt_names]
   DNS.1 = examplepetstore.com
   DNS.2 = api.examplepetstore.com
   
   [dn_requirements]
   countryName               = US
   stateOrProvinceName       = California
   localityName              = San Francisco
   0.organizationName        = example
   organizationalUnitName    = test
   commonName                = examplepetstore.com
   emailAddress              = [e-mail]
   
   EOF
   

2. Créez la CSR (server.csr) pour le certificat de serveur.

   openssl req -new \
       -sha256 -newkey rsa:2048 -nodes \
       -config server.config \
       -keyout server.key -out server.csr
   

3. Signez la CSR pour émettre le certificat de serveur X.509 (server.cert). La CSR est signée par le certificat intermédiaire.

   openssl x509 -req \
       -CAkey int.key -CA int.cert \
       -days 365 \
       -extfile server.config \
       -extensions extension_requirements \
       -in server.csr -out server.cert
   

   Lorsque l'équilibreur de charge se connecte au serveur backend, le serveur backend présente son certificat (server.cert) pour s'authentifier auprès de l'équilibreur de charge, ce qui termine le processus d'authentification du backend.

Options de configuration SSL supplémentaires sur un serveur Web Apache

Cette section facultative vous explique comment mettre à jour les options de configuration SSL sur un serveur Apache en fonction des certificats de serveur que vous avez créés précédemment.

1. Copiez la clé privée (server.key) et le certificat de serveur (server.cert) sur le serveur Web Apache.

       cat > server.key << EOF
       -----BEGIN PRIVATE KEY-----
       [...]
       -----END PRIVATE KEY-----
       EOF
   
       sudo cp ./server.key /etc/ssl/private/server.key
       

   Remplacez [...] par la clé privée du serveur encodée au format PEM que vous avez créée précédemment.

       cat > server.cert << EOF
       -----BEGIN CERTIFICATE-----
       [...]
       -----END CERTIFICATE-----
       EOF
   
       sudo cp ./server.cert /etc/ssl/certs/server.cert
       

   Remplacez [...] par le certificat de serveur encodé en PEM que vous avez créé précédemment.

2. Mettez à jour la configuration SSL du serveur Web Apache.

   Mettez à jour la configuration SSL d'Apache pour activer le trafic HTTPS à l'aide du certificat SSL et de la clé privée spécifiés.

       sudo vi /etc/apache2/sites-available/default-ssl.conf
   
       ----
       SSLCertificateFile      /etc/ssl/certs/server.cert
       SSLCertificateKeyFile /etc/ssl/private/server.key
       ----
       

3. Recalculer les hachages des certificats CA.

       sudo c_rehash /etc/ssl/certs/
       

4. Redémarrez le serveur Web Apache pour appliquer les modifications.

       sudo systemctl restart apache2.service
       

Étape suivante

• Configurer mTLS pour le backend
• Présentation de mTLS
• Configurer le protocole mTLS avec une autorité de certification privée