Conecta apps a instancias mediante SSH

Las aplicaciones pueden usar cuentas de servicio para ejecutar tareas automáticas y, además, interactuar con otras API de Google Cloud. Permitir que las aplicaciones administren sus propias llaves SSH y se conecten a instancias puede ser útil para automatizar los procesos de administración del sistema. En este instructivo, se muestra cómo configurar apps para que tengan acceso a las instancias mediante conexiones SSH. La app de muestra de este instructivo usa una cuenta de servicio y acceso a SO para la administración de Llaves SSH.

Todo el código utilizado en este instructivo se encuentra en la página de GitHub GoogleCloudPlatform/python-docs-samples.

Objetivos

En el instructivo se abarcan las siguientes tareas:

Crear una cuenta de servicio y configurarla con el objetivo de proporcionar acceso SSH administrado con acceso a SO para las aplicaciones que se conectan a tus instancias
Crear una instancia asociada con tu cuenta de servicio
Configurar la app de muestra en tu instancia para que use la cuenta de servicio a fin de administrar sus propias Llaves SSH y establecer conexiones SSH.
Ejecutar la app en una instancia en la que esté asociada la cuenta de servicio
Ejecutar la app fuera de Compute Engine, donde debes proporcionar la Llave de la cuenta de servicio de forma manual y especificar parámetros SSH adicionales.

Costos

En este instructivo se usan componentes facturables de Google Cloud, como Compute Engine.

Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Antes de comenzar

Accede a tu Cuenta de Google.
Si todavía no tienes una cuenta, regístrate para obtener una nueva.
En GCP Console, en la página de selección de proyecto, selecciona o crea un proyecto de GCP.
Nota : Si no planeas conservar los recursos que creas en este procedimiento, crea un proyecto en lugar de seleccionar un proyecto existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

Ir a la página de selección de proyecto
Asegúrate de tener habilitada la facturación para tu proyecto de Google Cloud Platform. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.
En tu cuenta de usuario personal, obtén las siguientes funciones de IAM para el proyecto:
- compute.instanceAdmin.v1
- compute.networkAdmin
- compute.osAdminLogin
- iam.serviceAccountAdmin
- iam.serviceAccountKeyAdmin
- iam.serviceAccountUser
Obtén información sobre cómo usar Cloud Shell para ejecutar comandos de la herramienta de línea de comandos de gcloud.

Crea y configura la cuenta de servicio y las instancias de ejemplo

Crea una cuenta de servicio y dos instancias para usarlas en este instructivo. Usarás la cuenta de servicio para otorgar a la aplicación acceso mediante SSH. La app se conectará de una instancia a otra a través de ese protocolo.

Sigue estos pasos para configurar el entorno de prueba:

Abre Cloud Shell en Console:
Abrir Cloud Shell
Exporta una variable de entorno a fin de establecer el ID del proyecto para futuros comandos:
```
export PROJECT_ID='[PROJECT_ID]'
```

Crea una nueva cuenta de servicio llamada ssh-account:

gcloud iam service-accounts create ssh-account --project $PROJECT_ID \
   --display-name "ssh-account"

Crea una red llamada ssh-example para usarla en este instructivo:

gcloud compute networks create ssh-example --project $PROJECT_ID

Crea una regla de firewall que habilite todas las conexiones SSH a las instancias de la red ssh-example:

gcloud compute firewall-rules create ssh-all --project $PROJECT_ID \
   --network ssh-example --allow tcp:22

Crea una instancia en us-central1-f llamada target. Esta será la instancia remota a la que se conectará la cuenta de servicio mediante SSH. Usa la marca --metadata para habilitar Acceso al SO en esta instancia específica. Incluye las marcas --no-service-account y --no-scopes, ya que la instancia no necesita ejecutar ninguna solicitud a la API para este ejemplo específico:
```
gcloud compute instances create target --project $PROJECT_ID \
   --zone us-central1-f --network ssh-example \
   --no-service-account --no-scopes \
   --machine-type f1-micro --metadata=enable-oslogin=TRUE
```
Otorga la función de IAM compute.osAdminLogin a la cuenta de servicio para que pueda establecer conexiones SSH específicamente con la instancia llamada target. La función compute.osAdminLogin también otorga a la cuenta de servicio privilegios de superusuario en la instancia. Aunque podrías otorgar esta función a nivel del proyecto para que se aplique a todas las instancias del proyecto, otorga esta función a nivel de la instancia a fin de controlar el acceso SSH de forma más detallada. Puedes otorgar permisos adicionales a tu cuenta de servicio más adelante si descubres que tus aplicaciones requieren acceso a otros recursos en tu proyecto:
```
gcloud compute instances add-iam-policy-binding target \
   --project $PROJECT_ID --zone us-central1-f \
   --member serviceAccount:ssh-account@$PROJECT_ID.iam.gserviceaccount.com \
   --role roles/compute.osAdminLogin
```

Crea una instancia en us-central1-f llamada source. Asocia la instancia con la cuenta de servicio ssh-account. Además, especifica el alcance cloud-platform, que se requiere para que la cuenta de servicio ejecute solicitudes a la API en esta instancia:

gcloud compute instances create source \
   --project $PROJECT_ID --zone us-central1-f \
   --service-account ssh-account@$PROJECT_ID.iam.gserviceaccount.com  \
   --scopes https://www.googleapis.com/auth/cloud-platform \
   --network ssh-example --machine-type f1-micro

Ahora, la cuenta de servicio puede administrar sus propios pares de Llaves SSH y puede usar SSH para conectarse específicamente a la instancia target. Debido a que la instancia source está asociada con la cuenta de servicio ssh-account que creaste, las bibliotecas cliente de Cloud para Python pueden usar credenciales predeterminadas de la aplicación a fin de autenticarse como la cuenta de servicio y usar las funciones que otorgaste a esa cuenta de servicio con anterioridad.

A continuación, configura y ejecuta una app que pueda establecer una conexión SSH de una instancia a otra.

Ejecuta una app SSH en una instancia

Cuando las apps que se ejecutan en tus instancias requieren acceso SSH a otras instancias, puedes administrar los pares de Llaves SSH para la cuenta de servicio y ejecutar comandos SSH de manera programática. Para este ejemplo ejecuta una app de muestra con el siguiente proceso:

Conéctate a la instancia source con la herramienta de línea de comandos de gcloud:
```
gcloud compute ssh source --project $PROJECT_ID --zone us-central1-f
```

En la instancia source, instala pip y la biblioteca cliente de Python:

my-username@source:~$ sudo apt update && sudo apt install python-pip -y && pip install --upgrade google-api-python-client

Descarga la aplicación de muestra service_account_ssh.py de GoogleCloudPlatform/python-docs-samples:

my-username@source:~$ curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/python-docs-samples/master/compute/oslogin/service_account_ssh.py

Ejecuta la app de muestra, que usa argparse para aceptar variables desde la línea de comandos. En este ejemplo, indica a la app que instale y ejecute cowsay en la instancia target. Para este comando agrega el ID del proyecto de forma manual:

my-username@source:~$ python service_account_ssh.py \
    --cmd 'sudo apt install cowsay -y && cowsay "It works!"' \
    --project [PROJECT_ID] --zone us-central1-f --instance target

⋮
___________
  It works!
-----------
       \   ^__^
        \  (oo)\_______
           (__)\       )\/\
               ||----w |
               ||     ||

Si la aplicación se ejecuta de forma correcta, recibirás el resultado de la app cowsay. Puedes modificar la marca --cmd para incluir cualquier comando que desees. De manera alternativa, puedes escribir tu propia app que importe service_account_ssh.py y la llame de forma directa.

Ejecuta exit para desconectarte de la instancia source y volver a Cloud Shell.

Ejecuta una app SSH fuera de Compute Engine

En el ejemplo anterior, ejecutaste la app en una instancia de Compute Engine en la que las bibliotecas cliente de Cloud para Python podían usar credenciales predeterminadas de la aplicación a fin de usar la cuenta de servicio asociada con la instancia source. Si ejecutas esta app fuera de una instancia de Compute Engine, la biblioteca cliente no puede acceder a la cuenta de servicio ni a sus permisos, a menos que proporciones la Llave de la cuenta de servicio de forma manual.

Obtén la dirección IP externa de la instancia target que creaste con anterioridad en este instructivo. Para ver esta dirección, puedes dirigirte a la página Instancias en Console o ejecutar el siguiente comando desde la herramienta de línea de comandos de gcloud:
```
gcloud compute instances describe target \
   --project $PROJECT_ID --zone us-central1-f
```
Crea una clave de cuenta de servicio para la cuenta de servicio ssh-account que usaste en el ejemplo anterior y descarga el archivo de claves en tu estación de trabajo local.
Copia la clave de la cuenta de servicio en el sistema en el que deseas ejecutar la muestra.
Abre una terminal en el sistema en el que deseas ejecutar esta muestra.
Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS para que apunte a la ruta en la que se encuentra el archivo de claves .json de tu cuenta de servicio. Si su clave está en la carpeta Downloads, puedes establecer una variable de entorno como se muestra en el siguiente ejemplo:
```
$ export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/key.json"
```
Instala los requisitos previos en este sistema:
1. Instala Python y pip. En los sistemas basados en Debian, puedes usar apt para completar este paso:
```
$ sudo apt update && sudo apt install python python-pip -y
```
2. Usa pip para instalar las bibliotecas cliente de Cloud para Python:
```
$ pip install --upgrade google-api-python-client
```

Descarga la app de muestra:

$ curl -O https://raw.githubusercontent.com/GoogleCloudPlatform/python-docs-samples/master/compute/oslogin/service_account_ssh.py

Ejecuta la app de muestra. Cuando ejecutas la app fuera de Compute Engine, el servidor de metadatos no está disponible, por lo que debes especificar el correo electrónico de la cuenta de servicio de forma manual. También debes especificar la dirección IP externa para la instancia target que obtuviste antes.

$ python service_account_ssh.py \
    --cmd 'sudo apt install cowsay -y && cowsay "It works!"' \
    --account ssh-account@[PROJECT_ID].iam.gserviceaccount.com \
    --project [PROJECT_ID] --hostname [TARGET_EXTERNAL_IP]

⋮
___________
  It works!
-----------
       \   ^__^
        \  (oo)\_______
           (__)\       )\/\
               ||----w |
               ||     ||

Si la aplicación se ejecuta de manera correcta, recibirás el resultado de la app cowsay.

Cómo funciona la app de muestra

La app de muestra service_account_ssh.py funciona mediante el siguiente proceso:

Inicializa el objeto de la API de acceso a SO.
Si no proporcionas la dirección de correo electrónico de la cuenta de servicio de forma manual, la app lee los metadatos de la instancia para identificar la cuenta de servicio asociada con la instancia. Si ejecutas esta app fuera de Compute Engine, debes proporcionar la dirección de la cuenta de servicio de forma manual.
Llama al método create_ssh_key() a fin de generar una Llave SSH temporal para la cuenta de servicio en la instancia en la que se ejecuta este ejemplo y agrega la clave pública a la cuenta de servicio con un temporizador de vencimiento que puedes especificar.
Llama al método getLoginProfile() desde la API de acceso a SO para obtener el nombre de usuario POSIX que usa la cuenta de servicio.
Llama al método run_ssh() para ejecutar un comando SSH remoto como la cuenta de servicio.
Imprime la respuesta desde el comando SSH remoto.
Quita los archivos de Llave SSH temporales.
El Acceso a SO quita los archivos de claves públicas de manera automática cuando pasa la fecha de vencimiento.

compute/oslogin/service_account_ssh.py

Ver en GitHub

def main(cmd, project, instance=None, zone=None,
         oslogin=None, account=None, hostname=None):
    """Run a command on a remote system."""

    # Create the OS Login API object.
    oslogin = oslogin or googleapiclient.discovery.build('oslogin', 'v1')

    # Identify the service account ID if it is not already provided.
    account = account or requests.get(
        SERVICE_ACCOUNT_METADATA_URL, headers=HEADERS).text
    if not account.startswith('users/'):
        account = 'users/' + account

    # Create a new SSH key pair and associate it with the service account.
    private_key_file = create_ssh_key(oslogin, account)

    # Using the OS Login API, get the POSIX user name from the login profile
    # for the service account.
    profile = oslogin.users().getLoginProfile(name=account).execute()
    username = profile.get('posixAccounts')[0].get('username')

    # Create the hostname of the target instance using the instance name,
    # the zone where the instance is located, and the project that owns the
    # instance.
    hostname = hostname or '{instance}.{zone}.c.{project}.internal'.format(
        instance=instance, zone=zone, project=project)

    # Run a command on the remote instance over SSH.
    result = run_ssh(cmd, private_key_file, username, hostname)

    # Print the command line output from the remote instance.
    # Use .rstrip() rather than end='' for Python 2 compatability.
    for line in result:
        print(line.decode('utf-8').rstrip('\n\r'))

    # Shred the private key and delete the pair.
    execute(['shred', private_key_file])
    execute(['rm', private_key_file])
    execute(['rm', private_key_file + '.pub'])

if __name__ == '__main__':

    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument(
        '--cmd', default='uname -a',
        help='The command to run on the remote instance.')
    parser.add_argument(
        '--project',
        help='Your Google Cloud project ID.')
    parser.add_argument(
        '--zone',
        help='The zone where the target instance is locted.')
    parser.add_argument(
        '--instance',
        help='The target instance for the ssh command.')
    parser.add_argument(
        '--account',
        help='The service account email.')
    parser.add_argument(
        '--hostname',
        help='The external IP address or hostname for the target instance.')
    args = parser.parse_args()

    main(args.cmd, args.project, instance=args.instance, zone=args.zone,
         account=args.account, hostname=args.hostname)

El método create_ssh_key() genera un nuevo par de Llaves SSH. Luego, el método llama a users().importSshPublicKey() desde la API de acceso a SO para asociar la clave pública con la cuenta de servicio. El método users().importSshPublicKey() también acepta un valor de vencimiento, que indica durante cuánto tiempo permanece válida la clave pública.

compute/oslogin/service_account_ssh.py

Ver en GitHub

def create_ssh_key(oslogin, account, private_key_file=None, expire_time=300):
    """Generate an SSH key pair and apply it to the specified account."""
    private_key_file = private_key_file or '/tmp/key-' + str(uuid.uuid4())
    execute(['ssh-keygen', '-t', 'rsa', '-N', '', '-f', private_key_file])

    with open(private_key_file + '.pub', 'r') as original:
        public_key = original.read().strip()

    # Expiration time is in microseconds.
    expiration = int((time.time() + expire_time) * 1000000)

    body = {
        'key': public_key,
        'expirationTimeUsec': expiration,
    }
    oslogin.users().importSshPublicKey(parent=account, body=body).execute()
    return private_key_file

Como práctica recomendada, configura tus cuentas de servicio a fin de generar nuevos pares de claves para ellas con regularidad. En este ejemplo, la cuenta de servicio crea un par de claves nuevo para cada conexión SSH que establece, pero puedes modificar esto a fin de que se ejecute en un horario que se adapte mejor las necesidades de tu app.

El cuerpo de la solicitud para users().importSshPublicKey() incluye el valor expirationTimeUsec, que le indica al acceso a SO cuándo debe caducar la clave. Cada cuenta puede tener solo hasta 32 KB de datos de Llave SSH, por lo que es mejor configurar tus Llaves SSH públicas para que caduquen poco después de que tu cuenta de servicio haya completado sus operaciones.

Después de que tu cuenta de servicio configure las Llaves SSH, podrá ejecutar comandos remotos. En este ejemplo, la app usa el método run_ssh() para ejecutar un comando en una instancia remota y mostrar el resultado del comando.

compute/oslogin/service_account_ssh.py

Ver en GitHub

def run_ssh(cmd, private_key_file, username, hostname):
    """Run a command on a remote system."""
    ssh_command = [
        'ssh', '-i', private_key_file, '-o', 'StrictHostKeyChecking=no',
        '{username}@{hostname}'.format(username=username, hostname=hostname),
        cmd,
    ]
    ssh = subprocess.Popen(
        ssh_command, shell=False, stdout=subprocess.PIPE,
        stderr=subprocess.PIPE)
    result = ssh.stdout.readlines()
    return result if result else ssh.stderr.readlines()

Limpiar

Para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo, haz lo siguiente:

Abre Cloud Shell en Console:
Abrir Cloud Shell

Borra la instancia llamada source:

gcloud compute instances delete source \
   --project $PROJECT_ID --zone us-central1-f

Borra la instancia llamada target:

gcloud compute instances delete target \
   --project $PROJECT_ID --zone us-central1-f

Borra la cuenta de servicio ssh-account:

gcloud iam service-accounts delete ssh-account --project $PROJECT_ID

Borra la red llamada ssh-example:

gcloud compute networks delete ssh-example --project $PROJECT_ID

Pasos siguientes

Descarga y observa la muestra de código completa. La muestra completa incluye una pequeña muestra del uso de todos estos métodos juntos. No dudes en descargarla, modificarla y ejecutarla para adaptarla a tus necesidades.
Revisa la referencia de la API de Compute Engine y la referencia de la API de acceso a SO para aprender a realizar otras tareas con estas API.
Comienza a crear tus propias apps.