Packer: Demo

Hola amigos, espero que lo que les voy a compartir les sirva.
Para que esto les funcione bien tengan en cuenta lo siguiente:

1. Luego de haber abierto tu cuenta con AWS, debes de tener creada una instancia desde EC2 .

1. A dicha instancia creale una AMI.

1. De la región donde creaste tu instancia sacas el nombre de la región que debes poner en “region” del código packer.

1. De la AMI que creaste sacas el “source_ami” y el “owners” del código packer.

1. Por esta razon que leeras en esta documentación entenderás porque usamos “type”: “amazon-ebs” en el código packer. = https://www.packer.io/docs/builders/amazon

no suelo quejarme de los cursos pero me parece pésimo demo para empezar … hay que explicar la estructura, las bases antes y empezar con algo muy básico

Para crear las variables de entorno en Windows con Powershell se ejecuta:

$env:AWS_ACCESS_KEY_ID="clave"
$env:AWS_SECRET_ACCESS_KEY="clave"

Para revisar las varibles de entorno disponibles en el sistema windows usando Powershell, se ejecuta:

Get-ChildItem Env:

Hola, los archivos de este curso los encuentran aqui: https://github.com/yolitals/curso-terrafom/tree/master/demo-packer

creo que al demo le falta

1. explicar el que el onwer es el id de la cuenta de aws
2. que se debe crear primero una instancia de aws con centos para nosotros mismos crear nuestra AMI
3. y que en esa instancia que creamos debemos ejecutar el comando

<ssh-keygen -f ~/.ssh/packer-key -t rsa>

y tomar la info del .pub y pasarla al nuestro

<{
  "variables": {
    "aws_access_key":"{{env `AWS_ACCESS_KEY_ID`}}",
    "aws_secret_key":"{{env `AWS_SECRET_ACCESS_KEY`}}"
  },
  "builders": [{
      "type": "amazon-ebs",
      "access_key": "{{user `aws_access_key`}}",
      "secret_key": "{{user `aws_secret_key`}}",
      "region": "us-east-1",
      "source_ami":"ami-0598081c3b0a0ddb3",
      "source_ami_filter":{
        "owners":["983708054900"],
        "most_recent": true
      },
      "instance_type": "t2.micro",
      "ssh_username": "centos",
      "ami_name": "packer_demo"


    }],
  "provisioners": [{
    "type": "file",
    "source":"./scripts/packer-key.pub",
    "Destination": "~/ .ssh/"
    },
    {
    "type":"shell",
      "inline":["cat ~/.ssh/packer-key.pub >> ~/authoerized_keys"]
    },
    {
      "type": "shell",
      "script": "./scripts/instalar-docker.sh"
    }
  ]
}>

y este es mi log del demo

<==> amazon-ebs: Prevalidating any provided VPC information
==> amazon-ebs: Prevalidating AMI Name: packer_demo
    amazon-ebs: Found Image ID: ami-0598081c3b0a0ddb3
==> amazon-ebs: Creating temporary keypair: packer_5f76ac40-09bf-3dec-2533-cba1ba0df824
==> amazon-ebs: Creating temporary security group for this instance: packer_5f76ac44-2354-88dc-aa2d-4e48025d908c
==> amazon-ebs: Authorizing access to port 22 from [0.0.0.0/0] in the temporary security groups...
==> amazon-ebs: Launching a source AWS instance...
==> amazon-ebs: Adding tags to source instance
    amazon-ebs: Adding tag: "Name": "Packer Builder"
    amazon-ebs: Instance ID: i-06ec35b53212b15d6
==> amazon-ebs: Waiting for instance (i-06ec35b53212b15d6) to become ready...
==> amazon-ebs: Using ssh communicator to connect: 34.228.62.120
==> amazon-ebs: Waiting for SSH to become available...
==> amazon-ebs: Connected to SSH!
==> amazon-ebs: Uploading ./scripts/packer-key.pub => ~/ .ssh/
==> amazon-ebs: Provisioning with shell script: C:\Users\PC\AppData\Local\Temp\packer-shell712487247
==> amazon-ebs: Provisioning with shell script: ./scripts/instalar-docker.sh
    amazon-ebs: Loaded plugins: fastestmirror
    amazon-ebs: Loading mirror speeds from cached hostfile
    amazon-ebs:  * base: d36uatko69830t.cloudfront.net
    amazon-ebs:  * extras: d36uatko69830t.cloudfront.net
    amazon-ebs:  * updates: d36uatko69830t.cloudfront.net
    amazon-ebs: Resolving Dependencies
    amazon-ebs: --> Running transaction check
    amazon-ebs: ---> Package containerd.io.x86_64 0:1.3.7-3.1.el7 will be installed
amazon-ebs: --> Processing Dependency: container-selinux >= 2:2.74 for package: containerd.io-1.3.7-3.1.el7.x86_64
    amazon-ebs: ---> Package docker-ce.x86_64 3:19.03.13-3.el7 will be installed
    amazon-ebs: ---> Package docker-ce-cli.x86_64 1:19.03.13-3.el7 will be installed
    amazon-ebs: --> Running transaction check
    amazon-ebs: ---> Package container-selinux.noarch 2:2.119.2-1.911c772.el7_8 will be installed
    amazon-ebs: --> Finished Dependency Resolution
    amazon-ebs:
    amazon-ebs: Dependencies Resolved
==> amazon-ebs: Failed to start docker.service: Unit not found.
    amazon-ebs:
    amazon-ebs: ================================================================================
    amazon-ebs:  Package            Arch    Version                     Repository         Size
    amazon-ebs: ================================================================================
amazon-ebs: Installing:
    amazon-ebs:  containerd.io      x86_64  1.3.7-3.1.el7               docker-ce-stable   29 M
    amazon-ebs:  docker-ce          x86_64  3:19.03.13-3.el7            docker-ce-stable   24 M
    amazon-ebs:  docker-ce-cli      x86_64  1:19.03.13-3.el7            docker-ce-stable   38 M
    amazon-ebs: Installing for dependencies:
    amazon-ebs:  container-selinux  noarch  2:2.119.2-1.911c772.el7_8   extras             40 k
    amazon-ebs:
    amazon-ebs: Transaction Summary
    amazon-ebs: ================================================================================
    amazon-ebs: Install  3 Packages (+1 Dependent package)
    amazon-ebs:
    amazon-ebs: Total download size: 91 M
    amazon-ebs: Installed size: 385 M
    amazon-ebs: Is this ok [y/d/N]: Exiting on user command
    amazon-ebs: Your transaction was saved, rerun it with:
    amazon-ebs:  yum load-transaction /tmp/yum_save_tx.2020-10-02.04-28.owkeZ_.yumtx
==> amazon-ebs: Stopping the source instance...
    amazon-ebs: Stopping instance
==> amazon-ebs: Waiting for the instance to stop...
==> amazon-ebs: Creating AMI packer_demo from instance i-06ec35b53212b15d6
    amazon-ebs: AMI: ami-0e391adda4e7c88b7
==> amazon-ebs: Waiting for AMI to become ready...
==> amazon-ebs: Terminating the source AWS instance...
==> amazon-ebs: Cleaning up any extra volumes...
==> amazon-ebs: Destroying volume (vol-0bc4e731c31a0e763)...
==> amazon-ebs: Deleting temporary security group...
==> amazon-ebs: Deleting temporary keypair...
Build 'amazon-ebs' finished after 3 minutes 22 seconds.

==> Wait completed after 3 minutes 22 seconds

==> Builds finished. The artifacts of successful builds are:
--> amazon-ebs: AMIs were created:
us-east-1: ami-0e391adda4e7c88b7>

Importante tener en cuenta que en el archivo descriptivo el parámetro “ssh_username” hace referencia a los usuarios predefinidos para las AMI bases que se han usado para lanzar las instancias:

Para Amazon Linux 2 o la AMI de Amazon Linux, el nombre de usuario es ec2-user.
Para una AMI de CentOS, el nombre de usuario es centos.
Para una AMI de Debian, el nombre de usuario es admin.
Para una AMI de Fedora, el nombre de usuario es ec2-user o fedora.
Para una AMI de RHEL, el nombre de usuario es ec2-user o root.
Para una AMI de SUSE, el nombre de usuario es ec2-user o root.
Para una AMI de Ubuntu, el nombre de usuario es ubuntu.
Si ec2-user y root no funcionan, consulte con el proveedor de la AMI.

Comparto archivo de packer usando el AMI de Ubuntu 18.04 LTS:

{
    "variables": {
        "aws_access_key": "{{env `AWS_ACCESS_KEY`}}",
        "aws_secret_key": "{{env `AWS_SECRET_KEY`}}"
    },
    "builders": [{
         "type": "amazon-ebs",
         "access_key": "{{user `aws_access_key`}}",
         "secret_key": "{{user `aws_secret_key`}}",
         "region": "us-east-2",
         "source_ami": "ami-059d836af932792c3",
         "source_ami_filter": {
	          "owners": ["099720109477"],
              "most_recent": true
         },
         "instance_type": "t2.micro",
         "ssh_username": "ubuntu",
         "ami_name": "packer-ubuntu {{timestamp}}",
         "associate_public_ip_address": true
     }],
    "provisioners": [
        {
            "type": "file",
            "source": "./scripts/packer-key.pub",
            "destination": "~/.ssh/"
         },
         {
            "type": "shell",
            "inline": [
                "cat ~/.ssh/packer-key.pub >> ~/.ssh/authorized_keys"
            ]   
         },
         {
             "type": "shell",
             "script": "scripts/install-docker.sh"
         }
     ]
}

Cuando hice el paso a paso de crear el AMI a partir del código me arrojaba un error, yo estaba referenciando un AMI de la lista que ofrece AWS para crear una EC2 (Sin yo tener ningún AMI en mi cuenta), así que pensé que debía crear primero una instancia EC2 y luego a esta sacarle una imagen y la referencia de esta imagen si me permitía usarla en el código para que Packer generara el AMI. Pensé que debía haber una posibilidad de usar una AMI que ya ofrece AWS sin necesidad de crearla a partir de una instancia creada manualmente, mi solución fue quitar el key de owner en el archivo .json, de esta manera si me permitió crearla en mi propia lista de AMI

Si alguien elige ubuntu, este es el script:

#!/bin/bash
# Instalar Docker
sudo apt-get update -y

sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
sudo apt-get update
sudo apt-get install -y docker-ce
sudo service docker start

#Agregar el usuario ubuntu al grupo docker
sudo usermod -a -G docker ubuntu

Recuerden que en el ssh_username debe ir ubuntu

Este comentario es para reunir un comentario que encontré abajo y agregar algunos míos:

1. DAVID JULIAN MARTINEZ LUENGAS
ssh_username:
Este campo corresponde al usuario por defecto que cambia de acuerdo al SO, por ejemplo la profesora uso una maquina CentOS y coloco el usuario correspondiente.
En su comentario tiene una lista de usuarios por SO.

2. AMI origen
No tiene que sacarse de una instancia propia, se puede usar una del market solo es navegar en el panel de AMI y copiar los datos de una existente (aún no se insertar imágenes! ).

"source_ami": "ami-0d5eff06f840b45e9",
      "source_ami_filter": {
        "owners": ["137112412989"],
        "most_recent": true
      }

3. Instancia en ejecución
No es necesario tener una instancia en ejecución, packer crea una instancia y luego de crear la AMI la elimina.

4. Credenciales AWS CLI
Si configuraron una cuenta con aws cli pueden eliminar las variables relacionadas en el .json y packer tomara las del sistema.
Para usar perfiles en la sección de builders usar o mediante variable de entorno:

"variables": {
    },
    "builders": [{
      "type": "amazon-ebs",
      "region": "us-east-1",
      "source_ami": "ami-0d5eff06f840b45e9",
      "source_ami_filter": {
        "owners": ["137112412989"],
        "most_recent": true
      },
      "instance_type": "t2.micro",
      "ssh_username": "ec2-user",
      "ami_name": "packer-example {{timestamp}}"
    }]

AWS_PROFILE

https://www.packer.io/docs/builders/amazon

5. Script instalación docker con AWS Linux
El que compartió la profesora funciona en centos pero no en AWS Linux, lo modifique ligeramente

#!/bin/bash
# Instalar Docker
sudo yum update -y

sudo yum install docker -y
sudo service docker start

#Agregar el usuario centos al grupo docker
sudo usermod -a -G docker ec2-user

PESIMO CURSO!!! LO MAS MALO QUE PUEDES ENCONTRAR AQUI, MALA EXPLICACION, MALOS PASOS, MALO TODO NO LO RECOMIENDO NO PIERDAN SU TIEMPO

AMI (Amazon Machine Image) es importante tener claridad sobre este concepto puesto que se puede llegar a confundir.
Por otro lado en esta clase toman por entendido que ya se conoce y se ha trabajado con AWS, y que ya se ha creado una instancia para desde allí generar la AMI que se quiere usar, lo cual no tiene sentido puesto que le objetivo de esta debería ser en efecto generar una AMI a partir de un archivo descriptivo.

Lo malo del curso es que no explica el porque de las configuraciones que hace =(

Llegue a este curso esperando entender el uso de terraform, quizas por lo que es un curso avanzado hay temas que crean que ya uno debe entender pero cuando vi el curso no tenia prerequiistos por lo que entendi que no deberia. Lastima verdad que hay cosas que quedan sin respuestas o sin significado de un porque se colocan.

Muy mala la clase, si no es por los comentarios, es imposible lograr lo que se expone en el video.

para que se creo el archivo “credential” en el video anterior si las variables van a ser cargadas desde el entorno? este es un buen momento para aprender a usar un archivo .tfvars

Build ‘amazon-ebs’ errored: No valid credential sources found for AWS Builder. Please see https://www.packer.io/docs/builders/amazon.html#specifying-amazon-credentials for more information on providing credentials for the AWS Builder.
Quien me podria ayudar con esto por favor?

el peor curso de platzi…

Compañeros, si, falta bastante explicación, en general veo muy bien explicado en algunos comentarios el tema de crear una ec2 para obtener una ami y luego dependiendo el sistema operativo que se crea , se elije un userssh, que por cierto para la capa gratuita de Linux el usuario es “ec2-user” y el script para instalar docker es :
#!/bin/bash

Instalar Docker

sudo yum update -y
sudo yum install docker -y
sudo service docker start
sudo groupadd docker
sudo usermod -a -G docker ec2-user

yo estuve recibiendo este error :

Build 'amazon-ebs' errored after 7 seconds 541 milliseconds: Error launching source instance: VPCResourceNotSpecified: The specified instance type can only be used in a VPC. A subnet ID or network interface ID is required to carry out the request.
        status code: 400, request id: 0f1ce8b3-2766-434b-b821-880bcb83ed09

hasta que agregue los siguientes configs en el builder

        "vpc_id": "vpc-xxxxxx",
        "subnet_id": "subnet-xxxxxxx"

Es necesario cambiar el owner del archivo para que aparezca en nuestro dashboard de aws.

Genere el build con el json del curso y no me genera nada.
Edite el json, eliminando el owner y por defecto me tomo mi owner de aws.

ahora observo el ami creado!!!

Es completamente necesario usar Packer para crear imágenes? Terraform no puede hacer esto?

$ ssh-keygen -f ~/.ssh/packer-key -t rsa
coloco este comando y me sale este error
Enter same passphrase again:
Saving key “~/.ssh/packer-key” failed: No such file or directory
Alguien que me ayude

Me paso esto
==> amazon-ebs: Error waiting for SSH: Packer experienced an authentication error when trying to connect via SSH. This can happen if your username/password are wrong. You may want to double-check your credentials as part of your debugging process. original error: ssh: handshake failed: ssh: unable to authenticate, attempted methods [none publickey], no supported methods remain

Yo logre sacar el ami, haciendo lo siguiente:

• Seleccionar la instancia
• Clic en el menú Acciones
• Clic en imagen
• Clic en crear imagen

Un curso con tanta relevancia deberia tener un profesor(a) que domine mucho mejor el tema y se explique mas detenidamente, le falta mucho.

Muy bueno, pero no es mejor usar Cloud config?

Estimada @Yolanda Lopez.

Considero que en este capitulo debe ser mas detallo , y no dar por sentado que se tiene el conocimiento en temas de AWS, es imposible lograr este capitulo sin la ayuda de los aportes de compañeros.

Les dejo algunos tips que me resultaron utilies a esta fecha.

1 - Darle una leida a lo aportes ya que los compañeros aportan mucho contexto de la practica.

2 - No necesitan crear una instancia EC2 y luego una AMI , pueden crearla a partir de AMI del marketplaces.

“source_ami_filter”: {
“filters”: {
“virtualization-type”: “hvm”,
“name”: “ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20221201”,
“root-device-type”: “ebs”
},
“owners”: [
“amazon”
],

2 - No es necesario que especiquen las variables de entorno terraform entiende por default esto si tienen el archivo credentials .

La explicación de esta clase esta muy floja, para las personas que estén estancada les comparto la siguiente guía:

1. si tienen inconvenientes con crear la llave SSH usen el siguiente comando:

 ssh-keygen -f ~/.ssh/packer-key -t rsa -b 4096

• El archivo packer-key.pub que se genera lo copian en la ruta e su proyecto.

1. para usar las variables de entorno en sistemas gnu/linux estas funcionan de formar temporal el la shell.

 export AWS_ACCESS_KEY_ID="NGRESE_CONTRSEÑA"
 export AWS_SECRET_ACCESS_KEY="INGRESE_CONTRSEÑA"

luego de agregarlas escriban el comando: source /etc/environment

verifiquen las variables con el comando:  printenv

1. Verifiquen el “source_ami” del sistema operativo que desean usar, estos cambian de forma esporádica.

2. En el archivo AWS-AMI.JSON revisen el usuario “ssh_username” corresponda al ami que estén usando.

3. Les comparto el archivo AWS-AMI.JSON esta con AMI el sistema es UBUNTU, verificar la ruta del directorio donde tengan ubicadas el archivo packer-key.pub.

{
    "variables": {
      "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
      "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
    },
    "builders": [
      {
        "type": "amazon-ebs",
        "access_key": "{{user `aws_access_key`}}",
        "secret_key": "{{user `aws_secret_key`}}",
        "region": "us-east-2",
        "source_ami": "ami-05803413c51f242b7",
        "instance_type": "t2.micro",
        "ssh_username": "ubuntu",
        "ami_name": "packer-demo {{timestamp}}"
      }
    ],
    "provisioners": [
      {
        "type": "file",
        "source": "INGRESE_SU_RUTA/demo-packer/scripts/packer-key.pub",
        "destination": "~/.ssh/"
      },
      {
        "type": "shell",
        "inline": [
          "cat ~/.ssh/packer-key.pub >> ~/.ssh/authorized_keys"
        ]
      },
      {
        "type": "shell",
        "script": "scripts/instalar-docker.sh"
      }
    ]
  }

1. copien el siguiente Codigo en el archivo instalar-docker-sh

#!/bin/bash
# Instalar Docker
sudo apt-get update -y

sudo apt install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
sudo apt-get update
sudo apt-get install -y docker-ce
sudo service docker start

#Agregar el usuario ubuntu al grupo docker
sudo usermod -a -G docker ubuntu

1. Al terminar todo el proceso ingresen a AWS y verifiquen que estén en la zona us-east-2 y van al apartado de AMI y verifican que se halla creado la instancia y la plantilla.

2. FIN …

En este enlace te indican como encontrar un AMI sin tener que que hacerlo desde una instancia

Find a Linux AMI

Hola muchas gracias por los aportes complementando lo que hace falta a esta clase.

Cuando ejecuto Packer.build aws.ami.json no se conecta por ssh y al final la instancia es terminada.

==> amazon-ebs: Error waiting for SSH: Packer experienced an authentication error when trying to connect via SSH. This can happen if your username/password are wrong. You may want to double-check your credentials as part of your debugging process. original error: ssh: handshake failed: ssh: unable to authenticate, attempted methods [none publickey], no supported methods remain

He creado incluso el archivo .pub dentro de una instancia creada previamente con centos y copiado el contenido al archivo .pub local pensando que ese podría ser el problema pero de igual forma no ha funcionado.

A alguien más le ha pasado?
![](

<code> 

)

No me gusta esta clase, no siento que haya bases para entrar de lleno a como se hizo en la clase.

Análisis de operación

Interesante aplicación al modo de operación con EC2.
.
Como se menciona, cuando trabajamos los servidores desde su definición en MV, tenemos una definición por completo de los recursos.
.
De mi parte, me quedo con la explicación y este taller demostrativo. Y en su caso, utilizaré esta implementación para el levantamiento pronto de recursos computaciones.

Tuve algunos problemas con los permisos del IAM en AWS, tuve que asignar los permisos que indican en: https://gmusumeci.medium.com/minimal-aws-iam-policy-for-packer-e4269b510a2d

Les comparto script bash mas completo para el ejemplo de docker para una AMI con ubuntu basado en la documentacion de docker:

#!/bin/bash

# Uninstall Old Versions
sudo apt remove docker docker-engine docker.io containerd runc

# Updates
sudo apt-get install -y
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# Add Docker’s official GPG key:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# set up the stable repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update -y && sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# Apply executable permissions to the binary
sudo chmod +x /usr/local/bin/docker-compose

# Add user to docker group
sudo groupadd docker
sudo usermod -aG docker ubuntu

# Print versions
docker-compose --version
docker --version 

Me funciono.

{
    "variables": {
        "aws_access_key": "{{env `AWS_ACCESS_KEY_ID`}}",
        "aws_secret_key": "{{env `AWS_SECRET_ACCESS_KEY`}}"
    },
    "builders": [{
        "type": "amazon-ebs",
        "access_key": "{{user `aws_access_key`}}",
        "secret_key": "{{user `aws_secret_key`}}",
        "region": "us-east-2",
        "source_ami": "ami-08ee2516c7709ea48",
        "source_ami_filter": {
            "owners": ["812083501456"],
            "most_recent": true
        },
        "instance_type": "t2.micro",
        "ssh_username": "centos",
        "ami_name": "packer-centos {{timestamp}}"
    }],
    "provisioners": [
        {
            "type": "file",
            "source": "./scripts/packer-key.pub",
            "destination": "~/.ssh/"
        },
        {
            "type": "shell",
            "inline":[
                "cat ~/.ssh/packer-key.pub >> ~/.ssh/authorized_keys"
            ]
        },
        {
            "type": "shell",
            "script": "scripts/instalar-docker.sh"
        }

    ]
}

Si tienen más dudas, recuerden que también pueden leer la documentación de Packer con aws:

https://learn.hashicorp.com/collections/packer/aws-get-started

AMI (Amazon Machine Image), debería darse claridad de este concepto pus puede tender a confundirse, por otra parte dan por hecho que ya se ha manipulado AWS y que ya se tiene una instancia creada allí para poder generar las propias AMI’s, lo cual tampoco tiene sentido puesto que el objetivo es crear una desde cero con el archivo descriptivo.

Tuve que cambiar el código un poco, al parecer hay parámetros que se declaran diferente. El resultado final en mi caso es un AMI con Ubuntu instalado y dentro de él Docker, para el cual usé este script:

https://get.docker.com/

El código luce así:

{
    "variables": {
        "aws_access_key": "{{env `AWS_ACCESS_KEY`}}",
        "aws_secret_key": "{{env `AWS_SECRET_KEY`}}"
    },
    "builders": [
        {
            "access_key": "{{user `aws_access_key`}}",
            "ami_name": "Docker-Image",
            "instance_type": "t2.micro",
            "region": "us-east-2",
            "secret_key": "{{user `aws_secret_key`}}",
            "associate_public_ip_address":"true",
            "source_ami_filter": {
              "filters": {
              "virtualization-type": "hvm",
              "name": "ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-20200907",
              "root-device-type": "ebs"
              },
              "owners": ["099720109477"],
              "most_recent": true
            },
            "ssh_username": "ubuntu",
            "type": "amazon-ebs"
        }
    ],
    "provisioners": [
        {
            "type": "file",
            "source": "./packer-key.pub",
            "destination": "~/.ssh/"
         },
         {
            "type": "shell",
            "inline": [
                "cat ~/.ssh/packer-key.pub >> ~/.ssh/authorized_keys"
            ]   
         },
         {
             "type": "shell",
             "script": "./instalar-docker.sh"
         }
     ]
}

![](

alguien que me puede ayudar con mi error
crea la instancia pero creo que tengo problemas packer-key.pub

“ssh_username”: NO es para definir el usuario que vas a crear sino un usuario existente que se pueda conectar por SSH a la instancia creada a partir de tu AMI base.

wow, esto combinado con docker 7u7.
Los AMIs parece que son diferentes por región, yo estoy en us-west-2 y tuve que cambiarla.

Referencia para instalar Docker en Debian Jessie (esta me fue bien):
https://elbinario.net/2016/10/07/docker-instalacion-en-debian-jessie/

Hola, como genero otra llave ssh-rsa…

ssh-rsa AAAAB3NzaC1y....PmU/iCfn [email protected]Pro-de-Yolanda.local..

Intente con:

ssh-keygen -t rsa -C "[email protected]"

Pero me agrega saltos de linea

De donde se saca el owner?

No queda muy claro esa parte…

Amigos, si alguno obtiene este error:

Build 'amazon-ebs' errored: error validating regions: AuthFailure: AWS was not able to validate the provided access credentials 
	status code: 401

La solución es agregar el valor del Token de sesión:
“aws_session_token”: “”
“token”:"{{user aws_session_token}}"

Buenas tardes, al momento de crear el AMI y validar la instancia me aparece el siguiente error.

Error: Failed to prepare build: “amazon-ebs”

1 error(s) occurred:

• Bad script ‘ssh/install-docker.sh’: stat ssh/install-docker.sh: no such file
  or directory