Activer les clés de sécurité avec OS Login

Console

Pour activer les clés de sécurité pour toutes les VM OS Login, définissez enable-oslogin et enable-oslogin-sk sur TRUE dans les métadonnées du projet à l'aide de la console Google Cloud :

1. Accédez à la page Métadonnées.

   Accéder à la page "Métadonnées"

2. Cliquez sur Modifier.

3. Cliquez sur Ajouter un élément.

   1. Dans le champ Clé, saisissez enable-oslogin.
   2. Dans le champ Valeur, saisissez TRUE.

4. Cliquez sur Ajouter un élément.

   1. Dans le champ Clé, saisissez enable-oslogin-sk.
   2. Dans le champ Valeur, saisissez TRUE.

5. Cliquez sur Enregistrer.

gcloud

Pour activer les clés de sécurité pour toutes les VM compatibles avec OS Login, exécutez la commande gcloud compute project-info add-metadata pour définir enable-oslogin=TRUE et enable-oslogin-sk=TRUE dans les métadonnées du projet :

gcloud compute project-info add-metadata \
    --metadata enable-oslogin=TRUE,enable-oslogin-sk=TRUE

Console

Pour activer les clés de sécurité sur une seule VM, utilisez la console Google Cloud pour définir enable-oslogin et enable-oslogin-sk sur TRUE dans les métadonnées d'instance :

1. Accédez à la page Instances de VM.

   Accéder à la page "Instances de VM"

2. Cliquez sur le nom de la VM pour laquelle vous souhaitez activer les clés de sécurité.

3. Cliquez sur Modifier.

4. Dans la section Métadonnées, cliquez sur Ajouter un élément.

   1. Dans le champ Clé, saisissez enable-oslogin.
   2. Dans le champ Valeur, saisissez TRUE.

5. Cliquez sur Ajouter un élément.

   1. Dans le champ Clé, saisissez enable-oslogin-sk.
   2. Dans le champ Valeur, saisissez TRUE.

6. Cliquez sur Enregistrer.

gcloud

Pour activer les clés de sécurité sur une seule VM, utilisez la commande gcloud compute instances add-metadata pour définir enable-oslogin=TRUE et enable-oslogin-sk=TRUE dans les métadonnées d'instance :

gcloud compute instances add-metadata VM_NAME \
    --metadata enable-oslogin=TRUE,enable-oslogin-sk=TRUE

Remplacez VM_NAME par le nom de votre VM.

Console

Lorsque vous vous connectez à des VM à l'aide de l'outil SSH dans le navigateur de la console Google Cloud, SSH dans le navigateur récupère les clés privées associées à vos clés de sécurité.

Pour vous connecter à une VM sur laquelle des clés de sécurité sont activées, procédez comme suit:

1. Dans Google Cloud Console, accédez à la page Instances de VM.

2. Dans la liste des VM, cliquez sur SSH sur la ligne de la VM à laquelle vous souhaitez vous connecter.

3. Lorsque vous y êtes invité, appuyez sur votre clé de sécurité.

gcloud

Lorsque vous vous connectez à des VM à l'aide de la CLI gcloud, la CLI gcloud récupère les clés privées associées à vos clés de sécurité et configure les fichiers de clés privées. Cette configuration est persistante et s'applique à toutes les VM qui utilisent des clés de sécurité.

Exécutez la commande gcloud beta compute ssh pour vous connecter à une VM sur laquelle des clés de sécurité sont activées :

gcloud beta compute ssh VM_NAME

Outils tiers

Avant de vous connecter à une VM sur laquelle des clés de sécurité sont activées, vous devez récupérer les clés privées associées à vos clés de sécurité et configurer les fichiers de clé privée. Cet exemple utilise la bibliothèque cliente Python pour effectuer la configuration.

Vous ne devez effectuer cette configuration que la première fois que vous vous connectez à une VM. La configuration est persistante et s'applique à toutes les VM qui utilisent des clés de sécurité dans votre projet.

Depuis un terminal de votre poste de travail, procédez comme suit :

1. Si ce n'est pas déjà fait, installez la bibliothèque cliente Google pour Python en exécutant la commande suivante :

   pip3 install google-api-python-client
   

2. Enregistrez l'exemple de script Python suivant, qui récupère les clés privées associées à vos clés de sécurité, configure les fichiers de clés privées et se connecte à la VM.

   compute/oslogin/physical_security_key_ssh.py

   Afficher sur GitHub Commentaires
   import argparse
   import os
   import subprocess
   from typing import Optional
   
   import googleapiclient.discovery
   
   def write_ssh_key_files(security_keys: list[dict], directory: str) -> list[str]:
       """
       Store the SSH key files.
   
       Saves the SSH keys into files inside specified directory. Using the naming
       template of `google_sk_{i}`.
   
       Args:
           security_keys: list of dictionaries representing security keys retrieved
               from the OSLogin API.
           directory: path to directory in which the security keys will be stored.
   
       Returns:
           List of paths to the saved keys.
       """
       key_files = []
       for index, key in enumerate(security_keys):
           key_file = os.path.join(directory, f"google_sk_{index}")
           with open(key_file, "w") as f:
               f.write(key.get("privateKey"))
               os.chmod(key_file, 0o600)
               key_files.append(key_file)
       return key_files
   
   def ssh_command(key_files: list[str], username: str, ip_address: str) -> list[str]:
       """
       Construct the SSH command for a given IP address and key files.
   
       Args:
           key_files: SSH keys to be used for authentication.
           username: username used to authenticate.
           ip_address: the IP address or hostname of the remote system.
   
       Returns:
           SSH command as a list of strings.
       """
       command = ["ssh"]
       for key_file in key_files:
           command.extend(["-i", key_file])
       command.append(f"{username}@{ip_address}")
       return command
   
   def main(
       user_key: str, ip_address: str, dryrun: bool, directory: Optional[str] = None
   ) -> None:
       """
       Configure SSH key files and print SSH command.
   
       Args:
           user_key: name of the user you want to authenticate as. Usually an email address.
           ip_address: the IP address of the machine you want to connect to.
           dryrun: bool flag to do dry run, without connecting to the remote machine.
           directory: the directory to store SSH private keys.
       """
       directory = directory or os.path.join(os.path.expanduser("~"), ".ssh")
   
       # Create the OS Login API object.
       oslogin = googleapiclient.discovery.build("oslogin", "v1beta")
   
       # Retrieve security keys and OS Login username from a user's Google account.
       profile = (
           oslogin.users()
           .getLoginProfile(name=f"users/{user_key}", view="SECURITY_KEY")
           .execute()
       )
   
       if "posixAccounts" not in profile:
           print("You don't have a POSIX account configured.")
           print("Please make sure that you have enabled OS Login for your VM.")
           return
   
       username = profile.get("posixAccounts")[0].get("username")
   
       # Write the SSH private key files.
       security_keys = profile.get("securityKeys")
   
       if security_keys is None:
           print(
               "The account you are using to authenticate does not have any security keys assigned to it."
           )
           print(
               "Please check your Application Default Credentials "
               "(https://cloud.google.com/docs/authentication/application-default-credentials)."
           )
           print(
               "More info about using security keys: https://cloud.google.com/compute/docs/oslogin/security-keys"
           )
           return
   
       key_files = write_ssh_key_files(security_keys, directory)
   
       # Compose the SSH command.
       command = ssh_command(key_files, username, ip_address)
   
       if dryrun:
           # Print the SSH command.
           print(" ".join(command))
       else:
           # Connect to the IP address over SSH.
           subprocess.call(command)
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser(
           description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
       )
       parser.add_argument("--user_key", help="Your primary email address.")
       parser.add_argument(
           "--ip_address", help="The external IP address of the VM you want to connect to."
       )
       parser.add_argument("--directory", help="The directory to store SSH private keys.")
       parser.add_argument(
           "--dryrun",
           dest="dryrun",
           default=False,
           action="store_true",
           help="Turn off dryrun mode to execute the SSH command",
       )
       args = parser.parse_args()
   
       main(args.user_key, args.ip_address, args.dryrun, args.directory)

3. Exécutez le script pour configurer vos clés et éventuellement vous connecter à la VM.

   python3 SCRIPT_NAME.py --user_key=USER_KEY --ip_address=IP_ADDRESS [--dryrun]
   

   Remplacez les éléments suivants :

   • SCRIPT_NAME : nom de votre script de configuration
   • USER_KEY : votre adresse e-mail principale.
   • IP_ADDRESS : adresse IP externe de la VM à laquelle vous vous connectez.
   • [--dryrun] (facultatif) : ajoutez l'option --dryrun pour imprimer la commande de connexion sans vous connecter à la VM. Si vous ne spécifiez pas cette option, le script exécute la commande de connexion.