Habilite chaves de segurança com login do sistema operacional

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Console

Para ativar chaves de segurança para todas as VMs habilitadas para login do SO, use o console do Google Cloud para definir enable-oslogin e enable-oslogin-sk como TRUE nos metadados do projeto:

1. Vá para a página Metadados .

   Vá para Metadados

2. Clique em Editar .

3. Clique em Adicionar item .

   1. No campo Chave , insira enable-oslogin .
   2. No campo Valor , insira TRUE .

4. Clique em Adicionar item .

   1. No campo Chave , insira enable-oslogin-sk .
   2. No campo Valor , insira TRUE .

5. Clique em Salvar .

gcloud

Para ativar chaves de segurança para todas as VMs habilitadas para login do SO, use o comando gcloud compute project-info add-metadata para definir enable-oslogin=TRUE e enable-oslogin-sk=TRUE nos metadados do projeto:

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

Console

Para ativar chaves de segurança em uma única VM, use o console do Google Cloud para definir enable-oslogin e enable-oslogin-sk como TRUE nos metadados da instância:

1. Acesse a página de instâncias de VM .

   Acesse as instâncias de VM

2. Clique no nome da VM para a qual você deseja habilitar chaves de segurança.

3. Clique em Editar .

4. Na seção Metadados , clique em Adicionar item .

   1. No campo Chave , insira enable-oslogin .
   2. No campo Valor , insira TRUE .

5. Clique em Adicionar item .

   1. No campo Chave , insira enable-oslogin-sk .
   2. No campo Valor , insira TRUE .

6. Clique em Salvar .

gcloud

Para ativar chaves de segurança em uma única VM, use o comando gcloud compute instances add-metadata para definir enable-oslogin=TRUE e enable-oslogin-sk=TRUE nos metadados da instância:

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

Substitua VM_NAME pelo nome da sua VM.

Console

Quando você se conecta a VMs usando a ferramenta SSH no navegador do console do Google Cloud, o SSH no navegador recupera as chaves privadas associadas às suas chaves de segurança.

Para se conectar a uma VM que tenha chaves de segurança habilitadas, faça o seguinte:

1. No console do Google Cloud, acesse a página de instâncias de VM .

2. Na lista de VMs, clique em SSH na linha da VM à qual você deseja se conectar.

3. Quando solicitado, toque na sua chave de segurança.

gcloud

Quando você se conecta a VMs usando a CLI gcloud, a CLI gcloud recupera as chaves privadas associadas às suas chaves de segurança e configura os arquivos de chave privada. Esta configuração é persistente e aplica-se a todas as VMs que utilizam chaves de segurança.

Use o comando gcloud beta compute ssh para se conectar a uma VM que tenha chaves de segurança ativadas:

gcloud beta compute ssh VM_NAME

Ferramentas de terceiros

Antes de se conectar a uma VM que tenha chaves de segurança habilitadas, você deverá recuperar as chaves privadas associadas às suas chaves de segurança e configurar os arquivos de chave privada. Este exemplo usa a biblioteca cliente Python para realizar a configuração.

Você só precisa realizar essa configuração na primeira vez que se conectar a uma VM. A configuração é persistente e se aplica a todas as VMs que usam chaves de segurança no seu projeto.

Em um terminal na sua estação de trabalho, faça o seguinte:

1. Instale a biblioteca cliente do Google para Python, caso ainda não o tenha feito, executando o seguinte comando:

   pip3 install google-api-python-client
   

2. Salve o exemplo de script Python a seguir, que recupera as chaves privadas associadas às suas chaves de segurança, configura os arquivos de chave privada e se conecta à 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. Execute o script para configurar suas chaves e, opcionalmente, conectar-se à VM.

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

   Substitua o seguinte:

   • SCRIPT_NAME : o nome do seu script de configuração.
   • USER_KEY : seu endereço de e-mail principal.
   • IP_ADDRESS : o endereço IP externo da VM à qual você está se conectando.
   • [--dryrun] : (opcional) adicione o sinalizador --dryrun para imprimir o comando de conexão sem conectar-se à VM. Se você não especificar esse sinalizador, o script executará o comando de conexão.