Cette page a été traduite par l'API Cloud Translation.

Configurer mTLS de backend

Cette page explique comment configurer le mTLS de backend à l'aide de certificats autogérés.

La procédure de configuration du mTLS de backend est semblable à celle du TLS authentifié par le backend, sauf que vous devez également créer un certificat pour l'équilibreur de charge. Ce certificat, également appelé certificat client, est associé à la ressource de configuration de l'authentification du backend. L'équilibreur de charge utilise ce certificat client pour s'authentifier auprès des backends.

Pour configurer mTLS de backend, vous devez procéder comme suit. Ces étapes sont décrites dans les sections suivantes de ce document.

Créez une ressource de configuration de confiance composée de certificats racines et intermédiaires.
Créez un certificat client et importez-le dans le gestionnaire de certificats.
Créez une ressource de configuration d'authentification de backend qui fait référence à la fois à la configuration de confiance et au certificat client.
Associez la ressource de configuration d'authentification de backend au service de backend de l'équilibreur de charge.

Avant de commencer

Consultez la présentation de la TLS authentifiée et du mTLS pour le 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 : API Compute Engine, API Certificate Manager, sécurité réseau et API Network Services. Pour en savoir plus, consultez Activer des API.
Configurez un équilibreur de charge 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 l'authentification mTLS du backend.

Opération	Autorisation
Créer une configuration de confiance	`certificatemanager.trustconfigs.create` sur le Google Cloud projet cible
Créer un certificat client	`certificatemanager.certs.create` sur le Google Cloud projet 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
Associez la ressource de configuration d'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 mTLS de backend en fonction de l'architecture illustrée dans le schéma suivant.

Composants de mTLS backend. — Composants mTLS de backend (cliquez pour agrandir).

Créer les certificats racine et intermédiaire

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

Un certificat racine se trouve en haut 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 entre le certificat de serveur et l'ancre de confiance configurée.

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

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 indiquent que le certificat convient à une autorité de certification. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez 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
```

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

Créez la demande 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

Signez la CSR pour créer le certificat intermédiaire X.509 (int.cert). La CSR 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 du truststore.

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 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 l'approbation, procédez comme suit :

Console

Dans la console Google Cloud , accédez à la page Certificate Manager.

Accéder au gestionnaire de certificats
Dans l'onglet Configurations d'approbation, cliquez sur Ajouter une configuration d'approbation.
Attribuez un nom à la configuration.
Pour Emplacement, sélectionnez Global ou Régional.

L'emplacement indique où la ressource de configuration de confiance est stockée. Pour les équilibreurs de charge d'application externes globaux, créez une ressource de configuration de confiance globale. Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, créez une ressource de configuration de l'approbation régionale.
Dans la section Truststore, cliquez sur Ajouter une ancre de confiance et importez le fichier de certificat encodé au format PEM, ou copiez le contenu du certificat.
Cliquez sur Ajouter.
Dans la section Truststore, cliquez sur Ajouter une autorité de certification intermédiaire, puis importez le fichier de certificat encodé au format PEM ou copiez le contenu du certificat. Cette étape vous permet d'ajouter un niveau de confiance entre le certificat racine et le certificat de votre serveur.
Cliquez sur Ajouter pour ajouter l'autorité de certification intermédiaire.
Pour ajouter le certificat que vous avez ajouté à la liste d'autorisation, cliquez sur Ajouter.
Cliquez sur Créer.

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

gcloud

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 intermédiaires, ajoutez des lignes pemCertificate dans la section appropriée.
Pour importer le fichier YAML de configuration de confiance, utilisez la commande gcloud certificate-manager trust-configs import.
global
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 TRUST_CONFIG_NAME par le nom de la configuration de confiance.
régional
Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, spécifiez la région dans laquelle la ressource de configuration de confiance est stockée.
```
gcloud certificate-manager trust-configs import TRUST_CONFIG_NAME \
    --source=trust_config.yaml \
    --location=REGION
```
Remplacez les éléments suivants :
- TRUST_CONFIG_NAME : nom de la ressource de configuration de confiance
- REGION : région où la ressource de configuration de confiance est stockée

Créer un certificat client

Dans le mTLS de backend, l'équilibreur de charge agit en tant que client et le backend en tant que serveur.

Pour activer le protocole mTLS de backend, l'équilibreur de charge doit prouver son identité au backend. Cette authentification est effectuée à l'aide d'un certificat client que l'équilibreur de charge présente au backend. Le serveur de backend doit valider le certificat client à l'aide de sa propre chaîne de confiance.

Lors de la connexion à un serveur backend, l'équilibreur de charge définit l'indication du nom du serveur (SNI) sur le nom d'hôte spécifié dans la configuration TLS. Le serveur backend sélectionne le certificat SSL/TLS approprié en fonction de cette valeur SNI. L'équilibreur de charge s'attend à ce que la valeur SNI corresponde à un autre nom de l'objet (SAN) figurant dans le certificat du serveur backend.

Les certificats client peuvent être des certificats gérés provenant d'une autorité de certification privée via Certificate Authority Service ou des certificats PKI privés autogérés. Dans cet exemple, le certificat client est émis à l'aide de certificats autogérés. Cette section utilise la bibliothèque OpenSSL pour créer le certificat de l'autorité de certification racine et le certificat client.

Pour créer un certificat client, procédez comme suit :

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 indiquent que le certificat convient à une autorité de certification (CA). L'attribut extendedKeyUsage est défini sur clientAuth. Pour en savoir plus sur les exigences concernant les certificats racine et intermédiaires, consultez 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=clientAuth

  EOF
```

Créez un certificat CA 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

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

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

  cat > client.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          = clientAuth

  [dn_requirements]
  countryName               = US
  stateOrProvinceName       = California
  localityName              = San Francisco
  0.organizationName        = example
  organizationalUnitName    = test
  commonName                = test.example.com
  emailAddress              = test@example.com

  EOF

Créez la CSR (client.csr) pour le certificat client.

  openssl req -new \
      -config client.config \
      -keyout client.key -out client.csr

Créez le certificat client (client.cert) à partir de la CSR. La CSR est signée par le certificat de l'autorité de certification racine pour émettre le certificat client X.509.

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

Importer le certificat client dans le gestionnaire de certificats

Pour importer le certificat client dans Certificate Manager, procédez comme suit :

Console

Dans la console Google Cloud , accédez à la page Certificate Manager.

Accéder au gestionnaire de certificats
Dans l'onglet Certificats, cliquez sur Ajouter un certificat.
Attribuez un nom au certificat.

Ce nom doit être unique au projet.
Facultatif : saisissez une description du certificat. La description vous permet d'identifier un certificat spécifique ultérieurement.
Pour Emplacement, sélectionnez Global ou Régional.

L'emplacement indique où la ressource de configuration de confiance est stockée. Pour les équilibreurs de charge d'application externes globaux, créez une ressource de configuration de confiance globale. Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, créez une ressource de configuration de confiance régionale.
Dans le champ Scope (Niveau d'accès), sélectionnez Client Authentication (Authentification du client).
Dans Type de certificat, sélectionnez Créer un certificat autogéré.
Dans le champ Certificat, importez un fichier de certificat encodé au format PEM ou copiez et collez le contenu d'un certificat encodé au format PEM.
Dans le champ Certificat de clé privée, importez une clé privée encodée au format PEM qui n'est pas protégée par une phrase secrète, ou copiez et collez le contenu de la clé privée encodée au format PEM.
Spécifiez un libellé à associer au certificat. Si nécessaire, vous pouvez ajouter plusieurs libellés. Pour ajouter un libellé, cliquez sur le bouton Ajouter un libellé, puis spécifiez une clé (key) et une valeur (value) pour votre libellé.
Cliquez sur Créer. Vérifiez que le nouveau certificat apparaît dans la liste des certificats.

gcloud

Pour importer le certificat client dans le gestionnaire de certificats, utilisez la commande gcloud certificate-manager certificates create. La portée de ce certificat est client-auth, ce qui indique qu'il est utilisé comme certificat client dans le protocole mTLS du backend.
global
Pour les équilibreurs de charge d'application externes globaux, créez un certificat Certificate Manager global.
```
gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
    --certificate-file=client.cert \
    --private-key-file=client.key \
    --scope=client-auth \
    --location=global
```
Remplacez CLIENT_CERTIFICATE_NAME par le nom de la ressource de certificat client. Ce certificat client avec le champ d'application client-auth est utilisé par la ressource de configuration de l'authentification du backend.
régional
Pour les équilibreurs de charge d'application externes régionaux et les équilibreurs de charge d'application internes régionaux, créez un certificat Certificate Manager régional.
```
gcloud certificate-manager certificates create CLIENT_ CERTIFICATE_NAME \
    --certificate-file=client.cert \
    --private-key-file=client.key \
    --scope=client-auth \
    --location=REGION
```
Remplacez les éléments suivants :
- CLIENT_CERTIFICATE_NAME : nom de la ressource de certificat client. Ce certificat client avec le champ d'application client-auth est utilisé par la ressource de configuration de l'authentification du backend.
- REGION : région dans laquelle le certificat doit être créé.

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

Dans la console Google Cloud , accédez à la page Configuration de l'authentification.
Accéder à la configuration de l'authentification
Dans l'onglet Authentification du backend, cliquez sur Créer.
Saisissez le nom de la ressource de configuration d'authentification de backend.
Pour Emplacement, sélectionnez Global ou Régional.
Sélectionnez la ressource de certificat client que vous avez créée précédemment.
Facultatif : Sélectionnez les racines de confiance publiques.
Sélectionnez la ressource de configuration de confiance que vous avez créée précédemment.
Cliquez sur Créer.

Vérifiez que la ressource de configuration d'authentification de backend s'affiche.

gcloud

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.
global

Associez le certificat client à la ressource de configuration d'authentification de backend pour activer le mTLS de 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
clientCertificate: projects/PROJECT_ID/locations/global/certificates/CLIENT_ CERTIFICATE_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 de l'authentification du backend est définie
- PROJECT_ID : ID de votre projet Google Cloud
- BACKEND_AUTH_CONFIG_NAME : nom de la ressource de configuration de l'authentification du backend
- TRUST_CONFIG_NAME : nom de la ressource de configuration de confiance que vous avez créée précédemment
- CLIENT_CERTIFICATE_NAME : nom de la ressource de certificat client que vous avez créée précédemment
régional

Associez le certificat client à la ressource de configuration d'authentification de backend pour activer le mTLS de backend.
```
cat << EOF > BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml
name: projects/PROJECT_ID/locations/REGION/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
trustConfig: projects/PROJECT_ID/locations/REGION/trustConfigs/TRUST_CONFIG_NAME
clientCertificate: projects/PROJECT_ID/locations/REGION/certificates/CLIENT_ CERTIFICATE_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 de l'authentification du backend est définie
- PROJECT_ID : ID de votre projet Google Cloud
- REGION : nom de la région
- BACKEND_AUTH_CONFIG_NAME : nom de la ressource de configuration de l'authentification du backend
- TRUST_CONFIG_NAME : nom de la ressource de configuration de confiance que vous avez créée précédemment
- CLIENT_CERTIFICATE_NAME : nom de la ressource de certificat client que vous avez créée précédemment
Pour importer la configuration d'authentification de backend, utilisez la commande gcloud network-security backend-authentication-configs import.
global
```
gcloud 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
régional
```
gcloud network-security backend-authentication-configs import BACKEND_AUTH_CONFIG_NAME \
    --source=BACKEND_AUTHENTICATION_CONFIG_RESOURCE_FILENAME.yaml \
    --location=REGION
```
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
- REGION : nom de la région

Associez la ressource de configuration d'authentification de backend au service de backend de l'équilibreur de charge.

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

Console

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

Accéder à la page Équilibrage de charge
Dans l'onglet Backends, sélectionnez le service de backend pour lequel vous devez activer le TLS authentifié par le backend et le mTLS de backend.
Cliquez sur Modifier ().
Développez la section Configurations avancées.
Dans la section Authentification du backend, cochez la case Activer.
Facultatif : Spécifiez le nom d'hôte SNI et les SAN acceptés pour valider le certificat du backend.
Pour associer la ressource de configuration d'authentification de backend au service de backend, sélectionnez-la dans la liste Configuration d'authentification de backend.
Cliquez sur Continuer.
Pour mettre à jour les paramètres du service de backend, cliquez sur Mettre à jour.

gcloud

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.
Pour exporter la configuration du service de backend vers un fichier, utilisez la commande gcloud compute backend-services export.
global
```
gcloud 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 de backend est exportée
régional
```
gcloud compute backend-services export BACKEND_SERVICE_NAME \
    --destination=BACKEND_SERVICE_FILENAME.yaml \
    --region=REGION
```
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 de backend est exportée
- REGION : nom de la régionGoogle Cloud où se trouve le service de backend
Mettez à jour l'attribut tlsSettings du service de backend en le pointant vers la ressource de configuration d'authentification de backend. De plus, 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.
global
Associez la ressource de configuration d'authentification de backend globale au service de backend.

Les valeurs SNI et SAN de la déclaration YAML suivante ne sont fournies qu'à titre d'exemple. Vous pouvez les remplacer par des valeurs réelles adaptées à votre configuration.
```
  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
  
```
Remplacez les éléments suivants :
- BACKEND_SERVICE_FILENAME : nom du fichier YAML dans lequel la configuration du service de 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
régional
Associez la ressource de configuration d'authentification de backend régionale au service de backend.

Les valeurs SNI et SAN de la déclaration YAML suivante ne sont fournies qu'à titre d'exemple. Vous pouvez les remplacer par des valeurs réelles adaptées à votre configuration.
```
  cat << EOF >> BACKEND_SERVICE_FILENAME.yaml
  tlsSettings:
    authenticationConfig: //networksecurity.googleapis.com/projects/PROJECT_ID/locations/REGION/backendAuthenticationConfigs/BACKEND_AUTH_CONFIG_NAME
    sni: examplepetstore.com
    subjectAltNames:
    - dnsName: examplepetstore.com
    - dnsName: api.examplepetstore.com
  EOF
  
```
Remplacez les éléments suivants :
- BACKEND_SERVICE_FILENAME : nom du fichier YAML dans lequel la configuration du service de backend est exportée
- PROJECT_ID : ID de votre projet Google Cloud
- REGION : nom de la régionGoogle Cloud dans laquelle la configuration de l'authentification du backend est créée
- BACKEND_AUTH_CONFIG_NAME : nom de la ressource de configuration de l'authentification du backend
Pour importer la configuration mise à jour du service de backend à partir d'un fichier, utilisez la commande gcloud compute backend-services import.
global
```
  gcloud 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
régional
```
  gcloud compute backend-services import BACKEND_SERVICE_NAME \
      --source=BACKEND_SERVICE_FILENAME.yaml \
      --region=REGION
```
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
- REGION : nom de la régionGoogle Cloud où se trouve le service de backend

Créer un certificat de serveur de 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 permet d'établir une chaîne de confiance du certificat de serveur à 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 :

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 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              = test@examplepetstore.com

EOF

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

Signez la RDC pour émettre le certificat de serveur X.509 (server.cert). La RDC 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, celui-ci 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 client et serveur que vous avez créés précédemment.

Copiez la clé privée du serveur (server.key) et le certificat du 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é au format PEM que vous avez créé précédemment.

Importez le certificat client dans la configuration de confiance du serveur pour valider le certificat client.
```
      cat > client.cert << EOF
      -----BEGIN CERTIFICATE-----
      [...]
      -----END CERTIFICATE-----
      EOF

      sudo cp ./client.cert /etc/ssl/certs/client.cert
      
```
Remplacez [...] par le certificat client encodé au format PEM que vous avez créé précédemment.

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
    ----

Mettez à jour la configuration SSL d'Apache pour exiger l'authentification par certificat client et spécifier le certificat CA pour la validation.

    sudo vi /etc/apache2/sites-available/default-ssl.conf

    ----
    SSLVerifyClient require
    SSLVerifyDepth 5
    SSLCACertificateFile /etc/ssl/certs/client.cert
    ----

Réindexez les certificats CA.
```
    sudo c_rehash /etc/ssl/certs/
    
```
Redémarrez le serveur Web Apache pour appliquer les modifications.
```
    sudo systemctl restart apache2.service
    
```

Configurer mTLS de backend Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Autorisations

Vue d'ensemble de la configuration

Créer les certificats racine et intermédiaire

Mettre en forme les certificats

Créer une configuration de confiance

Console

gcloud

global

régional

Créer un certificat client

Importer le certificat client dans le gestionnaire de certificats

Console

gcloud

global

régional

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

Console

gcloud

global

régional

global

régional

Associez la ressource de configuration d'authentification de backend au service de backend de l'équilibreur de charge.

Console

gcloud

global

régional

global

régional

global

régional

Créer un certificat de serveur de backend

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

Étapes suivantes

Configurer mTLS de backend