amazon ec2 - ec2 - ¿Cómo agregar múltiples claves para la instancia elástica beanstalk?

download key pair amazon ec2

Question

Hay una muy buena pregunta sobre [Cómo hacer] SSH a Elastic [una] instancia de Beanstalk , pero una cosa que noté es que, a través de este método, solo es posible agregar una clave SSH.

¿Cómo puedo agregar varias claves SSH a una instancia? ¿Hay una manera de agregar automáticamente múltiples claves a nuevas instancias?

Answer 1

La forma más dinámica de agregar varias claves SSH a las instancias de Elastic Beanstalk EC2

Paso 1

Crea un grupo en IAM. Llámalo algo así como beanstalk-access . Agregue los usuarios que necesitan acceso SSH a ese grupo en IAM. También agregue sus claves públicas ssh a sus Security credentials IAM.

Paso 2

La siguiente secuencia de comandos de implementación analizará los datos JSON de AWS CLI utilizando una herramienta útil de Linux llamada jq ( tutorial oficial de jq ), por lo que debemos agregarlos en .ebextensions:

  packages:
    yum:
      jq: []

Paso 3

Agregue el siguiente script de implementación BASH a .ebextensions:

  files:
    "/opt/elasticbeanstalk/hooks/appdeploy/post/980_beanstalk_ssh.sh":
      mode: "000755"
      owner: ec2-user
      group: ec2-user
      content: |
        #!/bin/bash
        rm -f /home/ec2-user/.ssh/authorized_keys
        users=$(aws iam get-group --group-name beanstalk-access | jq ''.["Users"] | [.[].UserName]'')
        readarray -t users_array < <(jq -r ''.[]'' <<<"$users")
        declare -p users_array
        for i in "${users_array[@]}"
        do
        user_keys=$(aws iam list-ssh-public-keys --user-name $i)
        keys=$(echo $user_keys | jq ''.["SSHPublicKeys"] | [.[].SSHPublicKeyId]'')
        readarray -t keys_array < <(jq -r ''.[]'' <<<"$keys")
        declare -p keys_array
        for j in "${keys_array[@]}"
        do
        ssh_public_key=$(aws iam get-ssh-public-key --encoding SSH --user-name $i --ssh-public-key-id $j | jq ''.["SSHPublicKey"] .SSHPublicKeyBody'' | tr -d /")
        echo $ssh_public_key >> /home/ec2-user/.ssh/authorized_keys
        done
        done
        chmod 600 /home/ec2-user/.ssh/authorized_keys
        chown ec2-user:ec2-user /home/ec2-user/.ssh/authorized_keys

Desafortunadamente, debido a que se trata de YAML, no puede sangrar el código para que sea más fácil de leer. Pero vamos a desglosar lo que está pasando:

• (En el fragmento de código directamente debajo) Estamos eliminando el archivo de clave SSH predeterminado para otorgar el control total de esa lista a este script de implementación.

    rm -f /home/ec2-user/.ssh/authorized_keys

• (En el fragmento de código directamente debajo) Al usar AWS CLI, obtenemos la lista de usuarios en el beanstalk-access , y luego estamos canalizando esa lista JSON en jq para extraer solo esa lista de usuarios $.

    users=$(aws iam get-group --group-name beanstalk-access | jq ''.["Users"] | [.[].UserName]'')

• (En el fragmento de código directamente debajo) Aquí, convertimos la lista de $users JSON $users en una matriz BASH y la $users_array .

  readarray -t users_array <<(jq -r ''. []'' <<< "$ users") declara -p users_array

• (En el fragmento de código directamente debajo) Comenzamos a recorrer la matriz de usuarios.

    for i in "${users_array[@]}"
    do

• (En el fragmento de código directamente debajo) Esto probablemente se puede hacer en una línea, pero está tomando la lista de claves SSH asociadas a cada usuario en el beanstalk-access . Todavía no lo ha convertido en una matriz BASH, sigue siendo una lista JSON.

    user_keys=$(aws iam list-ssh-public-keys --user-name $i)
    keys=$(echo $user_keys | jq ''.["SSHPublicKeys"] | [.[].SSHPublicKeyId]'')

• (En el fragmento de código directamente debajo) Ahora está convirtiendo esa lista JSON de las claves SSH de cada usuario en una matriz BASH.

   readarray -t keys_array < <(jq -r ''.[]'' <<<"$keys")
   declare -p keys_array

• (En el fragmento de código directamente debajo) Ahora está convirtiendo esa lista JSON en una matriz BASH.

   readarray -t keys_array < <(jq -r ''.[]'' <<<"$keys")
   declare -p keys_array

• (En el fragmento de código directamente debajo) Ahora pasamos por la matriz de claves SSH de cada usuario.

   for j in "${keys_array[@]}"
   do

• (En el fragmento de código directamente debajo) Estamos agregando cada clave SSH para cada usuario al archivo authorized_keys .

  ssh_public_key=$(aws iam get-ssh-public-key --encoding SSH --user-name $i --ssh-public-key-id $j | jq ''.["SSHPublicKey"] .SSHPublicKeyBody'' | tr -d /")
  echo $ssh_public_key >> /home/ec2-user/.ssh/authorized_keys

• (En el fragmento de código directamente debajo) Cierre el bucle $users_keys y el bucle $users_keys .

  done
  done

• (En el fragmento de código que aparece a continuación) Proporcione al archivo authorized_keys los mismos permisos que tenía originalmente.

  chmod 600 /home/ec2-user/.ssh/authorized_keys
  chown ec2-user:ec2-user /home/ec2-user/.ssh/authorized_keys

Etapa 4

Si su instancia de Elastic Beanstalk EC2 está en una subred pública, puede simplemente ssh en ella usando:

ssh ec2-user@ip-address -i /path/to/private/key

Si su instancia de Elastic Beanstalk EC2 está en una subred privada (como debería ser para las mejores prácticas de seguridad en la nube), entonces deberá tener una instancia de EC2 "bastion server" que actuará como la puerta de enlace para canalizar todo el acceso SSH a las instancias de EC2. . Busque ssh proxy commands ssh agent forwarding o ssh proxy commands para tener una idea de cómo llevar a cabo el túnel SSH.

Añadiendo nuevos usuarios

Todo lo que debe hacer es agregarlos a su grupo de beanstalk-access IAM y ejecutar un despliegue, y esa secuencia de comandos los agregará a sus instancias de Elastic Beanstalk.

Answer 2

Combinando las respuestas de rhunwicks y rch850, aquí hay una manera limpia de agregar claves SSH adicionales, al tiempo que se conserva el conjunto a través de la consola de AWS:

files:
  /home/ec2-user/.ssh/extra_authorized_keys:
    mode: "000400"
    owner: ec2-user
    group: ec2-user
    content: |
      ssh-rsa AAAB3N...QcGskx keyname
      ssh-rsa BBRdt5...LguTtp another-key
commands:
  01_append_keys:
    cwd: /home/ec2-user/.ssh/
    command: sort -u extra_authorized_keys authorized_keys -o authorized_keys
  99_rm_extra_keys:
    cwd: /home/ec2-user/.ssh/
    command: rm extra_authorized_keys

Tenga en cuenta que eb ssh solo funcionará si el archivo de clave privada tiene el mismo nombre que la clave privada definida en la consola de AWS.

Answer 3

Crear un archivo llamado .ebextensions/authorized_keys.config es otra forma de hacerlo.

files:
  /home/ec2-user/.ssh/authorized_keys:
    mode: "000400"
    owner: ec2-user
    group: ec2-user
    content: |
      ssh-rsa AAAB3N...QcGskx keyname
      ssh-rsa BBRdt5...LguTtp another-key

El nombre del archivo authorized_keys.config es arbitrario.

Answer 4

En lugar de ejecutar echo y almacenar sus claves en Git, puede cargar sus claves públicas a los usuarios de IAM en AWS y luego:

commands:
  copy_ssh_key_userA: 
    command: rm -f /home/ec2-user/.ssh/authorized_keys;aws iam list-users --query "Users[].[UserName]" --output text | while read User; do aws iam list-ssh-public-keys --user-name "$User" --query "SSHPublicKeys[?Status == ''Active''].[SSHPublicKeyId]" --output text | while read KeyId; do aws iam get-ssh-public-key --user-name "$User" --ssh-public-key-id "$KeyId" --encoding SSH --query "SSHPublicKey.SSHPublicKeyBody" --output text >> /home/ec2-user/.ssh/authorized_keys; done; done;

Answer 5

Siguiendo la respuesta de Jim Flanagan, puede obtener las claves agregadas a cada instancia creando .ebextensions/app.config en el directorio de origen de su aplicación con contenido:

commands:
  copy_ssh_key_userA: 
    command: echo "ssh-rsa AAAB3N...QcGskx userA" >> /home/ec2-user/.ssh/authorized_keys
  copy_ssh_key_userB: 
    command: echo "ssh-rsa BBRdt5...LguTtp userB" >> /home/ec2-user/.ssh/authorized_keys

Answer 6

Una forma en que podría lograr esto es crear un script de datos de usuario que agregue las claves públicas de los pares de claves adicionales que desea utilizar para ~ ec2-user / .ssh / authorized_keys, y ejecute la instancia con esos datos de usuario, por ejemplo :

#!
echo ssh-rsa AAAB3N...QcGskx keyname >> ~ec2-user/.ssh/authorized_keys
echo ssh-rsa BBRdt5...LguTtp another-key >> ~ec2-user/.ssh/authorized_keys

Answer 7

No, Elastic Beanstalk solo admite un solo par de teclas. Puede agregar claves SSH manualmente al archivo authorized_keys , pero las herramientas Elastic Beanstalk no las conocerán.

Answer 8

https://.com/a/16776129/7459377

el método más simple, como @rhunwicks pero con un símbolo ">" en la primera copia:

Saludos.