Attivare le chiavi di sicurezza con OS Login

Console

Per attivare le chiavi di sicurezza per tutte le VM con OS Login abilitato, utilizza la console Google Cloud per impostare enable-oslogin e enable-oslogin-sk su TRUE nei metadati del progetto:

1. Vai alla pagina Metadati.

   Vai a Metadati

2. Fai clic su Modifica.

3. Fai clic su Aggiungi elemento.

   1. Nel campo Key (Chiave), inserisci enable-oslogin.
   2. Nel campo Valore, inserisci TRUE.

4. Fai clic su Aggiungi elemento.

   1. Nel campo Key (Chiave), inserisci enable-oslogin-sk.
   2. Nel campo Valore, inserisci TRUE.

5. Fai clic su Salva.

gcloud

Per attivare le chiavi di sicurezza per tutte le VM con OS Login abilitato, utilizza il comando gcloud compute project-info add-metadata per impostare enable-oslogin=TRUE e enable-oslogin-sk=TRUE nei metadati del progetto:

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

Console

Per attivare le chiavi di sicurezza su una singola VM, utilizza la console Google Cloud per impostare enable-oslogin e enable-oslogin-sk su TRUE nei metadati dell'istanza:

1. Vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic sul nome della VM per cui vuoi attivare le chiavi di sicurezza.

3. Fai clic su Modifica.

4. Nella sezione Metadati, fai clic su Aggiungi elemento.

   1. Nel campo Key (Chiave), inserisci enable-oslogin.
   2. Nel campo Valore, inserisci TRUE.

5. Fai clic su Aggiungi elemento.

   1. Nel campo Key (Chiave), inserisci enable-oslogin-sk.
   2. Nel campo Valore, inserisci TRUE.

6. Fai clic su Salva.

gcloud

Per attivare i token di sicurezza su una singola VM, utilizza il comando gcloud compute instances add-metadata per impostare enable-oslogin=TRUE e enable-oslogin-sk=TRUE nei metadati dell'istanza:

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

Sostituisci VM_NAME con il nome della VM.

Console

Quando ti connetti alle VM utilizzando lo strumento SSH nel browser della console Google Cloud, lo strumento recupera le chiavi private associate alle tue chiavi di sicurezza.

Per connetterti a una VM con i token di sicurezza abilitati:

1. Nella console Google Cloud, vai alla pagina Istanze VM.

2. Nell'elenco delle VM, fai clic su SSH nella riga della VM a cui vuoi connetterti.

3. Quando richiesto, tocca il token di sicurezza.

gcloud

Quando ti connetti alle VM utilizzando gcloud CLI, gcloud CLI recupera le chiavi private associate alle tue chiavi di sicurezza e configura i file delle chiavi private. Questa configurazione è permanente e si applica a tutte le VM che utilizzano token di sicurezza.

Utilizza il comando gcloud beta compute ssh per connetterti a una VM in cui sono abilitati i token di sicurezza:

gcloud beta compute ssh VM_NAME

Strumenti di terze parti

Prima di connetterti a una VM con i token di sicurezza abilitati, devi recuperare le chiavi private associate ai token di sicurezza e configurare i file delle chiavi private. Questo esempio utilizza la libreria client Python per eseguire la configurazione.

Devi eseguire questa configurazione solo la prima volta che ti colleghi a una VM. La configurazione è permanente e si applica a tutte le VM che utilizzano token di sicurezza nel progetto.

Da un terminale sulla tua workstation, svolgi i seguenti passaggi:

1. Se non l'hai ancora fatto, installa la libreria client di Google per Python eseguendo il seguente comando:

   pip3 install google-api-python-client
   

2. Salva il seguente script Python di esempio, che recupera le chiavi private associate alle tue chiavi di sicurezza, configura i file delle chiavi private e si connette alla VM.

   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. Esegui lo script per configurare le chiavi e, facoltativamente, connettiti alla VM.

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

   Sostituisci quanto segue:

   • SCRIPT_NAME: il nome dello script di configurazione.
   • USER_KEY: il tuo indirizzo email principale.
   • IP_ADDRESS: l'indirizzo IP esterno della VM a cui ti connetti.
   • [--dryrun]: (Facoltativo) aggiungi il flag --dryrun per stampare il comando di connessione senza connetterti alla VM. Se non specifichi questo flag, lo script esegue il comando di connessione.