Sicherheitsschlüssel mit OS Login aktivieren

In diesem Dokument wird beschrieben, wie Sie mithilfe der in Ihrem Google-Konto registrierten physischen Sicherheitsschlüssel eine Verbindung zu VM-Instanzen herstellen, die OS Login verwenden.

Physische Sicherheitsschlüssel werden verwendet, um private SSH-Schlüsseldateien für die Verbindung zu VMs zu generieren. Wenn Sie über das SSH im Browser der Google Cloud Console oder die Google Cloud CLI über Sicherheitsschlüssel eine Verbindung zu VMs herstellen, ruft OS Login die private SSH-Schlüsseldatei ab, die mit Ihrem Sicherheitsschlüssel verknüpft ist, und konfiguriert die SSH-Schlüsseldatei. Wenn Sie eine Verbindung über Drittanbietertools herstellen, müssen Sie die SSH-Schlüsselinformationen mit der OS Login API abrufen und die SSH-Schlüsseldatei selbst konfigurieren.

Hinweise

  • Fügen Sie einen Sicherheitsschlüssel zu Ihrem Google-Konto hinzu.
  • Richten Sie OS Login ein.
  • Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich wie folgt bei Compute Engine authentifizieren.

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. REST

      Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

      Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Beschränkungen

  • VMs, für die Sicherheitsschlüssel aktiviert sind, akzeptieren nur Verbindungen von SSH-Schlüsseln, die an die in Ihrem Google-Konto registrierten physischen Sicherheitsschlüssel angehängt sind.

  • Sowohl die VM als auch die Workstation, über die Sie eine Verbindung herstellen, müssen eine Version von OpenSSH 8.2 oder höher verwenden, die SSH-Typen für Sicherheitsschlüssel unterstützt. Die folgenden Compute Engine-VM-Betriebssysteme unterstützen Sicherheitsschlüssel:

    • Debian 11 oder höher
    • SUSE Linux Enterprise Server (SLES) 15 (oder höher)
    • Ubuntu 20.04 LTS (oder höher)
    • Container-Optimized OS 93 LTS (oder höher)
    • Rocky Linux 9 (oder höher)

    Führen Sie folgenden Befehl aus, um zu prüfen, ob Ihre Umgebung Sicherheitsschlüssel unterstützt:

    ssh -Q key | grep ^sk-

    Wenn der Befehl keine Ausgabe zurückgibt, unterstützt Ihre Umgebung Sicherheitsschlüssel nicht.

Sicherheitsschlüssel mit OS Login aktivieren

Sie können die Verwendung von Sicherheitsschlüsseln für alle VMs aktivieren, die OS Login in Ihrem Projekt verwenden, oder für einzelne VMs.

Sicherheitsschlüssel für alle VMs mit OS Login in einem Projekt aktivieren

Zum Aktivieren von Sicherheitsschlüsseln auf allen VMs, die OS Login in Ihrem Projekt verwenden, verwenden Sie die Google Cloud Console oder die gcloud CLI.

Console

Wenn Sie Sicherheitsschlüssel für alle OS Login-fähigen VMs aktivieren möchten, legen Sie in der Google Cloud Console in den Projekt-Metadaten enable-oslogin und enable-oslogin-sk auf TRUE fest:

  1. Öffnen Sie die Seite Metadaten.

    Zur Seite "Metadaten"

  2. Klicken Sie auf Bearbeiten.

  3. Klicken Sie auf Zeile hinzufügen.

    1. Geben Sie im Feld Schlüssel enable-oslogin ein.
    2. Geben Sie im Feld Wert TRUE ein.

  4. Klicken Sie auf Zeile hinzufügen.

    1. Geben Sie im Feld Schlüssel enable-oslogin-sk ein.
    2. Geben Sie im Feld Wert TRUE ein.

  5. Klicken Sie auf Speichern.

gcloud

Um Sicherheitsschlüssel für alle OS Login-fähigen VMs zu aktivieren, legen Sie mit dem gcloud compute project-info add-metadata-Befehl die Werte enable-oslogin=TRUE und enable-oslogin-sk=TRUE in den Projekt-Metadaten fest:

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

Sicherheitsschlüssel auf einer einzelnen VM mit OS Login aktivieren

Verwenden Sie die Google Cloud Console oder die gcloud CLI, um Sicherheitsschlüssel auf einer VM zu aktivieren, die OS Login verwendet.

Console

Verwenden Sie zum Aktivieren von Sicherheitsschlüsseln auf einer einzelnen VM die Google Cloud Console, um enable-oslogin und enable-oslogin-sk in den Instanz-Metadaten auf TRUE festzulegen:

  1. Rufen Sie die Seite VM-Instanzen auf.

    Zu „VM-Instanzen“

  2. Klicken Sie auf den Namen der VM, für die Sie Sicherheitsschlüssel aktivieren möchten.

  3. Klicken Sie auf Bearbeiten.

  4. Klicken Sie im Abschnitt Benutzerdefinierte Metadaten auf Element hinzufügen.

    1. Geben Sie im Feld Schlüssel enable-oslogin ein.
    2. Geben Sie im Feld Wert TRUE ein.

  5. Klicken Sie auf Zeile hinzufügen.

    1. Geben Sie im Feld Schlüssel enable-oslogin-sk ein.
    2. Geben Sie im Feld Wert TRUE ein.

  6. Klicken Sie auf Speichern.

gcloud

Verwenden Sie den gcloud compute instances add-metadata-Befehl, um in den Instanz-Metadaten enable-oslogin=TRUE und enable-oslogin-sk=TRUE zu aktivieren und die Sicherheitsschlüssel auf einer einzelnen VM zu aktivieren:

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

Ersetzen Sie VM_NAME durch den Namen Ihrer VM.

Verbindung zu einer VM mit einem Sicherheitsschlüssel herstellen

Sie können über die Google Cloud Console, die gcloud CLI oder Tools von Drittanbietern eine Verbindung zu einer VM herstellen, die Sicherheitsschlüssel verwendet. Wenn Sie eine Verbindung zu VMs über die Google Cloud Console oder die gcloud CLI herstellen, konfiguriert Compute Engine den SSH-Schlüssel für Sie. Wenn Sie mit Drittanbietertools eine Verbindung zu VMs herstellen, müssen Sie die Konfiguration selbst vornehmen.

Console

Wenn Sie über das SSH im Browser-Tool der Google Cloud Console eine Verbindung zu VMs herstellen, ruft SSH im Browser die privaten Schlüssel ab, die Ihren Sicherheitsschlüsseln zugeordnet sind.

So stellen Sie eine Verbindung zu einer VM her, für die Sicherheitsschlüssel aktiviert sind:

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

  2. Klicken Sie in der Liste der VMs in der Zeile der VM, zu der Sie eine Verbindung herstellen möchten, auf SSH.

  3. Wenn Sie dazu aufgefordert werden, tippen Sie auf den Sicherheitsschlüssel.

gcloud

Wenn Sie über die gcloud CLI eine Verbindung zu VMs herstellen, ruft die gcloud CLI die privaten Schlüssel ab, die Ihren Sicherheitsschlüsseln zugeordnet sind, und konfiguriert die privaten Schlüsseldateien. Diese Konfiguration ist dauerhaft und gilt für alle VMs, die Sicherheitsschlüssel verwenden.

Verwenden Sie den Befehl gcloud beta compute ssh, um eine Verbindung zu einer VM herzustellen, für die Sicherheitsschlüssel aktiviert sind:

gcloud beta compute ssh VM_NAME

Drittanbieter-Tools

Bevor Sie eine Verbindung zu einer VM herstellen, für die Sicherheitsschlüssel aktiviert sind, müssen Sie die mit Ihren Sicherheitsschlüsseln verknüpften privaten Schlüssel abrufen und die privaten Schlüsseldateien konfigurieren. In diesem Beispiel wird die Konfiguration mit der Python-Clientbibliothek durchgeführt.

Sie müssen diese Konfiguration nur ausführen, wenn Sie erstmals eine Verbindung zu einer VM herstellen. Die Konfiguration ist persistent und gilt für alle VMs in Ihrem Projekt, die Sicherheitsschlüssel verwenden.

Führen Sie auf einem Terminal auf Ihrer Workstation die folgenden Schritte aus:

  1. Installieren Sie die Google-Clientbibliothek für Python, falls noch nicht geschehen. Führen Sie dazu den folgenden Befehl aus:

    pip3 install google-api-python-client

  2. Speichern Sie das folgende Python-Beispielskript, das die privaten Schlüssel abruft, die Ihren Sicherheitsschlüsseln zugeordnet sind, die privaten Schlüsseldateien konfiguriert und eine Verbindung zur VM herstellt.

    compute/oslogin/physical_security_key_ssh.py 
    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. Führen Sie das Script aus, um Ihre Schlüssel zu konfigurieren und optional eine Verbindung zur VM herzustellen.

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

    Dabei gilt:

    • SCRIPT_NAME: der Name Ihres Konfigurationsskripts.
    • USER_KEY: die primäre E-Mail-Adresse.
    • IP_ADDRESS: die externe IP-Adresse der VM, zu der Sie eine Verbindung herstellen möchten.
    • [--dryrun]: (Optional) Fügen Sie das Flag --dryrun hinzu, um den Verbindungsbefehl ohne Verbindung zur VM zu drucken. Wenn Sie dieses Flag nicht angeben, führt das Script den Verbindungsbefehl aus.

Nächste Schritte