No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

1D
18H
38M
23S

Packer: Demo

9/27
Recursos

Packer es una herramienta para construir imagines casi en cualquier proveedor de nube.

Instalaci贸n de Packer

En este link se encuentran las instrucciones para instalar packer en los diferentes sistemas operativos. En este documento se detallan las instrucciones para sistema operatio Mac y Linux.

$ curl -o /tmp/packer.zip https://releases.hashicorp.com/packer/1.4.2/packer_1.4.2_darwin_amd64.zip 

$ unzip /tmp/packer.zip -d /usr/local/bin

## En el siguiente link se encuentra la url de los binarios para los demas sistemas operativos https://www.packer.io/downloads.html

Demo

En esta demo se creara una AMI para AWS con una llave publica personalizada y con docker. En esta demo se asumir谩 que ya tienes una cuenta de AWS previamente creada.

  • Crear un usuario en tu cuenta de AWS y obtener las credenciales (secret_id y secret_key) de AWS.
  • Configurar las credenciales como variables de entorno.
     $ export AWS_ACCESS_KEY_ID=""
     $ export AWS_SECRET_ACCESS_KEY=""
    
  • Dentro del directorio scriptsse encuentra la llave publica que se agregara a la imagen base resultante. Por cuestiones se seguridad no se encuentra la llave privada por lo que se sugiere que se cree un set de llaves y se remplace el contendido del archivo scripts/packer-key.pub por el valor de llave publica generada (.pub). Para generar el set de llaves puedes seguir las siguientes instrucciones:
    $ ssh-keygen -f ~/.ssh/packer-key -t rsa
    # Este comando generar谩 2 archivos "packer-key" que contiene la llave privada y "packer-key.pub" que contiene la llave publica, el contenido de esta es el que e reemplazara en el archivo "scripts/packer-key.pub" dentro de esta carpeta.
    
  • Para validar la sintaxis del archivo de definici贸n que contiene todas las configuraciones necesarias se ejecutar谩 el siguiente comando:
    $ cd demo-packer
    $ packer validate aws-ami.json
    
  • Finalmente se procede a crear el AMI en la cuenta de AWS configurada previamente. y para ello es necesario ejecutar el siguiente commando
    $ cd demo-packer
    $ packer build aws-ami.json
    

Aportes 47

Preguntas 23

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渞egion鈥 del c贸digo packer.
  1. De la AMI que creaste sacas el 鈥渟ource_ami鈥 y el 鈥渙wners鈥 del c贸digo packer.
  1. Por esta razon que leeras en esta documentaci贸n entender谩s porque usamos 鈥渢ype鈥: 鈥渁mazon-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 鈥渟sh_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 鈥渃redential鈥 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 鈥榓mazon-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 鈥渆c2-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.

<h5>linea en archivo .json</h5>

鈥渟ource_ami_filter鈥: {
鈥渇ilters鈥: {
鈥渧irtualization-type鈥: 鈥渉vm鈥,
鈥渘ame鈥: 鈥渦buntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20221201鈥,
鈥渞oot-device-type鈥: 鈥渆bs鈥
},
鈥渙wners鈥: [
鈥渁mazon鈥
],

<h6>fuente https://blog.gruntwork.io/locating-aws-ami-owner-id-and-image-name-for-packer-builds-7616fe46b49a</h6>

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 鈥渟ource_ami鈥 del sistema operativo que desean usar, estos cambian de forma espor谩dica.

  2. En el archivo AWS-AMI.JSON revisen el usuario 鈥渟sh_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鈥檚 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鈥檚, 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

鈥渟sh_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:
鈥渁ws_session_token鈥: 鈥溾
鈥渢oken鈥:"{{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: 鈥渁mazon-ebs鈥

1 error(s) occurred:

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