Construyendo una imagen propia

Comandos de la clase 👨‍💻

Comandos:

$ mkdir imagenes (creo un directorio en mi máquina)
$ cd imagenes (entro al directorio)
$ touch Dockerfile (creo un Dockerfile)
$ code . (abro code en el direcotrio en el que estoy)

##Contenido del Dockerfile##
FROM ubuntu:latest
RUN touch /ust/src/hola-platzi.txt (comando a ejecutar en tiempo de build)
##fin##

$ docker build -t ubuntu:platzi . (creo una imagen con el contexto de build <directorio>)
$ docker run -it ubuntu:platzi (corro el contenedor con la nueva imagen)
$ docker login (me logueo en docker hub)
$ docker tag ubuntu:platzi miusuario/ubuntu:platzy (cambio el tag para poder subirla a mi docker hub)
$ docker push miusuario/ubuntu:platzi (publico la imagen a mi docker hub)

jajaja… esta bueno el festejo !!!

Este profesor es tan bueno explicando que si más adelante actualizan nuevamente el curso de Docker, lo volvería a tomar por una tercera vez.

Si les ocurre el siguiente error:

failed to solve with frontend dockerfile.v0: failed to read dockerfile: open /var/lib/docker/tmp/buildkit-mount994817449/Dockerfile: no such file or directory

El error se produce por un mal nombramiento del archivo, el correcto es Dockerfile

Práctica

Se crea un directorio:

mkdir images

se accede al directorio:

cd imagenes

se crea un archivo llamado Dockerfile

touch Dockerfile

Contenido del Dockerfile:

FROM ubuntu:latest 
RUN touch /ust/src/hola-platzi.txt        # este comando se ejecutará en tiempo de build

Se crea una imágen, se le pasa el contexto de build

docker build -t ubuntu:platzi 

Iniciamos una conexión por terminal al contenedor de ubuntu

docker run -it ubuntu:platzi

para loguearse en docker hub, se ejecuta lo siguiente y se ponen las claves correspondientes

docker login

Para poder publicar nuestro contenedor, es necesario cambiar el tag ubuntu, dado que el mismo ya existe como un contenedor oficial y no tenemos permisos para modificarlo.

docker tag ubuntu:platzi miusuario/ubuntu:platzy

Una vez hecho el cambio ya podremos subirlo a una cuenta de docker hub

comando para hacer la publicación de nuestra imágen en docker hub

docker push miusuario/ubuntu:platzi

Puedes subir tu docker file a un repo GIT y cargarlo desde ahi para construir la imagen. Sin pasar por dockerhub

Problemas publicando la imagen

Tuve problemas siguiendo las instrucciones de esta sección, cuando trataba de publicar me decía acceso denegado y en mi repositorio me fije que la forma correcta de publicar era :

docker push [nombre_usuario_docker_hub]/[nombre:repositorio]:[tag_name]

Entonces hice un retag para que mi tag contuviera lo requerido para hacer push.

Dejo esto aquí por si le sirve a alguien más.

Dockerfile, es una receta de cocina para la creación de una imagen. Imágen, es la plantilla para la creación de Containers. 🤟🏼 (No saben, lo que me costó esto, lo estuve analizando desde el fin de semana.)

Les recomiendo ver el Quickstart de la documentación de Docker:

1. Build and run your image
2. Share images on Docker Hub

Yeeeey!

Para el que lleve tiempo buscando como ejecutar vscode desde la terminal aqui la info:

https://stackoverflow.com/questions/30065227/run-open-vscode-from-mac-terminal

Solo es desde VScode teclear
Command + Shift + P
y luego darle enter en la opción de
Shell Command : Install code in PATH

Llevaba varias clases preguntandome lo mismo jajajaja

Cuando las imagenes existentes no satisfacen nuestras necesidades es posible crear nuestra propia imagen, pero esta debe estar basada en otra imagen existente, se debe usar un archivo llamado Dockerfile (sin extension) el cual contiene las instraucciones para crear una nueva imagen.
El archivo Dockerfile siempre comienza con la instruccion FROM que indica la imagen en la que se basa
dentro del Dockerfile se puede usar otros comandos como RUN que ejecuta comandos shell

Para construir la imagen a partir del archivo se usa el comando

docker build -t <nombre-imagen>:<tag-imagen> <ubicación-archivo-Dockerfile> 

Con nuestra imagen personalizada podemos crear un contenedor y/o publicarlo en DockerHub con el comando

docker push <dockerhub-username>/<image>:<tag>

Para cambiar el TAG de una imagen usamos el comando

docker tag <current>:<tag> <dockerhub-username>/<image>:<tag>

La Clase:

Construir una imagen
docker build -t ubuntu:platzi . // ubicación donde esta el archivo Dockerfile
docker run -it ubuntu:platzi // insteractuar con la imagen de platzi
docker login // iniciar credenciales en dockerhub
docker image ls // listar imagenes
docker tag ubuntu:platzi luiscordero29/ubuntu:platzi
docker push luiscordero29/ubuntu:platzi

simpático el profe XD

si quires renombrar una imagen se hace de la siguiente manera:

docker tag ubuntu:platzi ubuntu:crileiton

ERROR AL CREAR EL BUILD

• Me salía un error al crearlo, y lo arregle escribiendo bien el archivo Dockerfile.
  Tenia:

FROM ubuntu: latest

RUN touch /usr/src/hola-platzi.txt

Y era:

FROM ubuntu:latest

RUN touch /usr/src/hola-platzi.txt

(Tenia un espacio de más)
Tengan cuidado!

Create an image

This process is based on the dockerfile (describe the image)

Steps:

1. Create docker file
2. Build the docker file
3. Get the image
4. Run the image
5. Get the container

All commands written on the dockerfile were executed on the execution time.
Agregando una capa de personalización

FROM ubuntu:latest

RUN touch /usr/src/hola-course.txt

Build the dockerfile
docker build -t ubuntu:course .

• Internamente estamos creando capas de images que ya existen
  
  

Publish docker image

Iniciar sesión
docker login

Renombrar una imagen
docker tag ubuntu:course mrinternauta/ubuntu:test
Solo se cambia el nombre (no se crea una nueva imagen)

Enviar
docker push mrinternauta/ubuntu:test

Cómo crear nuestras propias imagenes?

Esta basado en un archivo dockerfile: describe el contenido de la imagen para correr contenedores.

1. Crear un directorio nuevo

mkdir imagenes
cd imagenes
touch Dockerfile
code .

1. Generar el dockerfile

# Todo dockerfile estara basado en algo mas
FROM ubuntu:latest

# se corre en tiempo de build
RUN touch /usr/src/hola-platzi.txt

1. Correr el dockerfile
   • -t de tail (nombre:version) (ruta de acceso del build)

docker build -t ubuntu:platzi .

Docker construime una imagen llamada ubuntu:platzi utilizando el directorio actual como concepto de build, como en este directorio actual hay un dockerfile, docker va a utilizar ese archivo

1. Verificar la imagen

docker image ls

Una imagen es una forma logica de hablar de un conjunto de capas o layers, es como un tipo de arbol que todos llegan a la parte superior. Funcionan como las imagenes/versiones de git.

1. Correr un nuevo contenedor a partir de la imagen que crreamos

docker run -it ubuntu:platzi

1. Publicar nuestra imagen a docker hub
   login desde ubuntu: https://stackoverflow.com/questions/50151833/cannot-login-to-docker-account

docker image ls
docker tag ubuntu:platzi duarteru/ubuntu:platzi
docker push duarteru/ubuntu:platzi

Qué ocurre al retaggear una imagen?

No se crea una imagen distinta, solo se crea un tag y es simplemente un nombre que apunta a un layer.

Algo que a mi me paso alrededor del minuto 6:15,es que me marcaba un error al querer construir la imagen:

=> ERROR [2/2] RUN touch /usr/src/hola-platzi.txt

lo corregi cambiando el Dockerfile a que solo fuera:
RUN touch /hola-platzi.txt

Asumo esto dado que no siempre existirá una ruta /usr/src dentro de la imagen ubuntu.

Para los que creen la cuenta en docker hub, ultimamente pide habilitar el 2FA con Google Authenticator, y cuando hagan el docker login, el password debe ser un token que generen desde la página de dockerhub

para las personas que se quedaron atoradas (como yo) en el tema de VS code, aqui les dejo un video que encontre donde se explica como hacer la configuracion para que sirva como en el video.

https://www.youtube.com/watch?v=1jH3nEzv8zk&ab_channel=AzureTar

Este curso genera la misma Serendipia que el curso de Gii y Github. La sensación de pequeñas grandes victorias💚.

Yay!

En mi caso estoy trabajando con windows y el comando touch no funciona, por ello utilice:

type nul > Dockerfile

Crear y ejecutar dockerfile

Dockefile indica como esta contruida nuesta imagen, con build creamos una imagen y la imagen crea un contenedor

super las imagenes que agrego para explicar!

A veces en Linux el comando de docker login lanza errores, lo ideal es borrar el archivo de configuración de docker ubicado en rm ~/.docker/config.json
Luego se vuelve a ejecutar el comando de docker login y listo

Aquí les comparto un link de los pasos que se necesitan
para loguearse utilizando un access token.
https://docs.docker.com/docker-hub/access-tokens/

docker login con 2FA activo, no funciona

Comandos de la clase de hoy (bash script) Link

Para saber un poco sobre lo que sucede cuando se crea una imagen:

    Sending build context to Docker daemon  2.048kB         
#se agrega el contexto del Dockerfile al daemon de Docker para su ejecución

Step 1/2 : FROM ubuntu:latest                            
#primera instrucción

 ---> 825d55fb6340                                          
#este ID es una capa

Step 2/2 : RUN touch /usr/src/hello-platzi.txt              
#segunda instrucción                        

 ---> Running in 961f545340bd                               
#segundo ID, otra capa

Removing intermediate container 961f545340bd               
#se remueve una capa intermedia

 ---> e2b414d4957c                                          
#se construye la imagen

Successfully built e2b414d4957c                             
#aviso de construcción exitosa de esta capa

Successfully tagged ubuntu:platzi                           
#aviso de taggeo exitoso de la imagen

Wow, q cool todo este nuevo conocimiento. Excelente poder compartir nuestras imagenes.

Extensiones en vscode que te ayudan en esta clase.
Docker ms-azuretools.vscode-docker
Remote - SSH ms-vscode-remote.remote-ssh
EN WINDOWS — deben editar el archivo config ubicado en
C:\users\tu-usuario.ssh\config

Host alias-server
    HostName <ip de servidor>
    User <usuario-remoto>
    IdentityFile <E:\ruta\mi-llave.pem>

Con eso podriamos conectarnos por ssh desde vscode.

Fuente de los deseos :v

Build imagen con un tag:

docker build -t ubuntu:custom .

Re-tag image

docker tag ubuntu:custom <your-user-id>/ubuntu:custom

Login to Docker Hub:

docker login --username <your-user-id>
$ Password:
Login Succeeded

Push image:

docker push <your-user-id>/ubuntu:custom

En Windows10 , si les aparece el siguiente error al hacer docker login:

PS C:\Users\jaarevalo\Documents\Developer\Cursos\Docker\images> docker login
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xc0000005 code=0x0 addr=0x0 pc=0xa4ddce]

goroutine 1 [running]:
github.com/docker/cli/cli/command.ConfigureAuth(0x2168e40, 0xc0004aa680, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20cf301, 0xc000539030, 0xc000535968)
        /go/src/github.com/docker/cli/cli/command/registry.go:128 +0x8e
github.com/docker/cli/cli/command/registry.runLogin(0x2168e40, 0xc0004aa680, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, ...)
        /go/src/github.com/docker/cli/cli/command/registry/login.go:123 +0x228
github.com/docker/cli/cli/command/registry.NewLoginCommand.func1(0xc00044eb00, 0x317e6b8, 0x0, 0x0, 0x0, 0x0)
        /go/src/github.com/docker/cli/cli/command/registry/login.go:45 +0xd1
github.com/docker/cli/vendor/github.com/spf13/cobra.(*Command).execute(0xc00044eb00, 0xc000538ce0, 0x0, 0x0, 0xc00044eb00, 0xc000538ce0)
        /go/src/github.com/docker/cli/vendor/github.com/spf13/cobra/command.go:850 +0x467
github.com/docker/cli/vendor/github.com/spf13/cobra.(*Command).ExecuteC(0xc0004182c0, 0xc000538ce0, 0x1, 0x1)
        /go/src/github.com/docker/cli/vendor/github.com/spf13/cobra/command.go:958 +0x350
github.com/docker/cli/vendor/github.com/spf13/cobra.(*Command).Execute(...)
        /go/src/github.com/docker/cli/vendor/github.com/spf13/cobra/command.go:895
main.runDocker(0xc0004aa680, 0x20d2060, 0xc000006020)
        /go/src/github.com/docker/cli/cmd/docker/docker.go:287 +0x1d8
main.main()
        /go/src/github.com/docker/cli/cmd/docker/docker.go:298 +0xf8

Basta con poner sus credenciales de dockerHub como parametros

docker login --username <usuario> --password <contraseña>

https://hub.docker.com/r/jhonsu777/ubuntu mi imagen publica en docker hub

Les comparto una guia que para complementar lo visto en la clase sobre Dockerfile

Para que les ayude en las líneas de código bájense esta extensión en el Visual Studio code.

Name: Docker
Id: ms-azuretools.vscode-docker
Description: Makes it easy to create, manage, and debug containerized applications.
Version: 1.22.2
Publisher: Microsoft
VS Marketplace Link: https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-docker

Si alguien tiene este problema al hacer el push.

Se soluciona con este comando para poner nuestro user al tag.
docker tag name_image[:tag] name_user_docker/name_image[:tag]

maravilloso este modelo de imagenes de docker!

Hola compañeros

Tuve un error al momento de loguearme:

Client.Timeout exceeded while awaiting headers

Estoy usando wsl 2 con Docker en Windows 10

Lo solucioné así: stackoverflow

Tip: Iniciar sesión con Token.

Extension de VS Code oficial para Docker 😃
https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-docker

Para renombrar el TAG de una imagen--->docker tag imagenbase nombredeltag/imagenbase

Crea una imagen con base ubuntu y tag platzi en el directorio actual----> docker build -t ubuntu:platzi .

Les comparto mi repo de la clase

https://hub.docker.com/repository/docker/bryancitu/ubuntu

imágenes que hace la parte para subir las propias versiones o versionados

Increible

Me encanta como Docker es eficiente en el espacio tanto local como en la mismisima plataforma, ya que comparte “punteros”

Los comandos dentro del DockerFile se corren/ejecutan en tiempo de build.

De esta clase aprendí que las imágenes son como los ogros ¡tienen capas! XD

Este profesor explica genial se nota cuanto le gusta la herramienta ya hice su anterior curso y era bueno pero este me gusta aún más espero que si hacen nuevas actualizaciones a docker también haga el curso el.

• Para crear imágenes en docker usamos los Dockerfile.
  • FROM, nos indica la imagen o la capa base que usaremos para crear nuestra imagen.
  • RUN, para ejecutar comandos en nuestra imagen base.
• docker built -t imagename:tag ., para construir nuestra imagen, a partir del docker file que se encuentra en el contexto de build . , el nombre de la imagne tag imagename:tag.
• docker tag imagename:tag <user_dockerhub>/imagename:tag, para etiquetar la imagen creada a mi repositorio en dockerhub
• docker push <user_dockerhub>/imagename:tag, para mandar la imagen a nuestro repositorio.
• Cuando se realiza el push, sólo se envías los cambios respecto a la imagen base que se encuentra en el repositorio.

Docker excelente tecnología, además un muy bn profesor

si la imagen es la plantilla para los contenedores… eso de entrada no es compartir archivos?? no hace a volume innecesario??