Ciclo de vida de un contenedor

Si no tienes Linux, puedes parar el contenedor con:

docker stop alwaysup

Donde ‘alwaysup’ es el nombre de tu cotenedor

Mis Notas del video:

Cada vez que un contendor se ejecuta, en realidad lo que ejecuta es un proceso del sistema operativo. Este proceso se le conoce como Main process.

Main process
Determina la vida del contenedor, un contendor corre siempre y cuando su proceso principal este corriendo.

Sub process
Un contenedor puede tener o lanzar procesos alternos al main process, si estos fallan el contenedor va a seguir encedido a menos que falle el main.

Ejemplos manejados en el video

• Batch como Main process
• Agujero negro (/dev/null) como Main process

docker run --name alwaysup -d ubuntu tail -f /dev/null 

_el ouput que te regresa es el ID del contentedor _

Te puedes conectar al contenedor y hacer cosas dentro del él con el siguiente comando (sub proceso)

docker exec -it alwaysup bash

Se puede matar un Main process desde afuera del contenedor, esto se logra conociendo el id del proceso principal del contenedor que se tiene en la maquina. Para saberlo se ejecuta los siguientes comandos;

docker inspect --format '{{.State.Pid}}' alwaysup

_El output del comando es el process ID (2474) _

Para matar el proceso principal del contenedor desde afuera se ejecuta el siguiente comando (solo funciona en linux)

Kill  2474

Comandos:

$ docker ps -a (veo todos los contenedores)
$ docker --name <nombre> -d ubuntu -f <comando>
$ docker --name alwaysup -d ubuntu tail -f /dev/null (mantiene el contenedor activo)
$ docker exec -it alwaysup bash (entro al contenedor)
$ docker inspect --format ‘{{.State.Pid}}’ alwaysup (veo el main process del ubuntu)
desde Linux si ejecuto kill -9 <PID> mata el proceso dentro del contenedor de ubuntu pero desde MAC no funciona

/dev/null

Es conocido como un agujero negro es decir ese archivo es la nada…

En mac corrí este comando para apagar el contenedor

docker kill alwaysup

Pienso que el profesor mezcla repetidas veces contenedor cuando se refiere a la imágen. Lo que se baja de docker hub es una imagen. Al hacer docker run esa imagen se convierte en contenedor.

hay dos formas de desplegar un contenedor que es en primer plano (Foreground) y en segundo plano (Background) por ejemplo:

dev/null es un barril sin fondo que loopea ubuntu para que mantenga vivo el proceso (segun entiendo).
Lo explica un poco mas en este video, tambien de guido https://platzi.com/clases/1432-docker-2018/15429-ciclo-de-vida-de-un-contenedor/

Otra forma de que el contenedor no se apague es

$ docker run --name alwaysup -d -it ubuntu

Tengo linux y no me funciono: Kill 6228, ni con sudo kill 6228.

[email protected]~$ kill 6228
kill: (6228) - Operación no permitida

Pero si pude con:

docker kill alwaysup

Si usas Debian o una distribución basada en ella puedes ejecutar lo siguiente:

sudo kill -9 "$(sudo docker inspect --format '{{.State.Pid}}' alwaysup)"```

El curso va excelente, ahora bien, en mac no mato el proceso pues le falto el parámetro -9 al kill, en cualquier unix system el comando es kill -9 PID mata el proceso mencionado, eso incluye a mac

no me funcionó mantener el contenedor abierto cuando ejecute el comando indicado:

docker run --name alwayup -d ubuntu tail -f /dev/null

buscando en internet encontre otra forma que si me funcionó:

docker run --name alwaysup -itd ubuntu

• Combinación de teclas para salir de un contenedor y apagarlo
  crtl + c

• Combinación de teclas para salir del contenedor sin apgarlo
  ctrl + d

• Comando para salir de un contenedor y apargarlo, si el proceso es un noOps
  $ exit

• Iniciar un contenedor ya creado
  $ docker start <nombre-contenedor o id-contenedor>

  Ejemplo
  $ docker start contenedor-ubuntu

• Detener un contenedor ya creado e iniciado
  $ docker start <nombre-contenedor o id-contenedor>

  Ejemplo
  $ docker stop contenedor-ubuntu

• Iniciar bash un contenedor ya creado
  $ docker exec -it <nombre-contenedor o id-contenedor>

    docker exec 
  

  Ejecutar dentro del contenedor

    -it  
  

  interactivo; terminal. Inicia un terminal modo interactivo

    <contenedor ID OR nombre contenedor >
  

  nombre del contenedor o el id

    bash
  

  bas o terminal

Ejemplo
$ docker exec -it contenedor-ubuntu

Tampoco funciona en un WSL de Ubuntu…

En el siguiente enlace podemos ver todas las imagenes oficiales de linux para docker
https://hub.docker.com/search?category=os&source=verified&type=image

Para ver la Pid , también lo pueden hacer de esta menera

docker inspect alwaysup | grep -i Pid

El flag “-d” : corre el contenedor en modo background e imprime el ID del contenedor.

*Códigos de error
en la documentación del proyecto Linux se encuentra una lista de códigos reservados que ofrece las recomendaciones de que códigos utilizar para escenarios específicos. Estos son los errores estándar de Linux y UNIX

• 1 Salida general de errores
• 2 Uso indebido de elementos integrados de shell
• 126 El comando invocado no se puede ejecutar
• 127 El comando no fue encontrado
• 128 Argumento invalido para salida
• 128+n Señal de error fatal “n”
• 130 Script terminado con Control+C
• 255* Estado de salida fuera de rango

ref: Exit status out of range

Para los que tiene WSL y no pueden matar el proceso es kill -9 pid

**Parar el proceso de un contenedor en Linux **

_Inspecciona y filtra el proceso del contenedor _

docker inspect --format '{{.State.Pid}}' nombre_contenedor

kill id_proceso

En mac

docker stop nombre_contenedor

¿Tengo una duda porque si el proceso principal se le asigna un id 1 dentro del contendor, desde afura se mata con otro ID?

docker inspect --format '{{.State.Pid}}' alwaysup

MY NOTES FOR CICLE OF LIFE A CONTAINER 😄

para salir de un contenedor utilizamos el comando exit y este se apaga

si ahora listamos los contenedores el contenedor ya no esta y se apagara

cada vez que un contenedor se ejecuta en realidad lo que ejecuta es un proceso del so

eso proceso es el que determina si el proceso sigue vivo o no de si esta funcionando o no

por defecto un contenedor corre siempre y cuando su proceso principal este corriendo

nosotros al hacer exit estamos acabando el proceso principal por lo tanto el contenedor se apaga.

Para que evitar que nuestro contenedor se apague entonces lo que hacemos es crearlo de otro modo, creando un ubuntu pero que no se apague si no que se quede ahí. Entonces lo que haremos es que cree otro proceso que no haga bin bash y que por lo tanto no podremos hacer que se apague.

Con este comando comando podremos correr el contenedor y al final indicarle que proceso queremos que corra.

docker run —name alwaysup -d ubuntu tail -f /dev/null

_el ouput que te regresa es el ID del contentedor _

/dev/null

Es conocido como un agujero negro es decir ese archivo es la nada…

/dev/full
/dev/zero
/dev/random

https://es.wikipedia.org/wiki//dev/zero

https://es.wikipedia.org/wiki//dev/null

https://es.wikipedia.org/wiki//dev/full

https://es.wikipedia.org/wiki//dev/random

Te puedes conectar al contenedor y hacer cosas dentro del él con el siguiente comando (sub proceso). Entonces podremos correr los archivos de linux pero sin que este sea el proceso superior si no un proceso del cual nos podremos salir sin que se apague.

docker exec -it alwaysup bash
								  name

Se puede matar un Main process desde afuera del contenedor, esto se logra conociendo el id del proceso principal del contenedor que se tiene en la maquina. Para saberlo se ejecuta los siguientes comandos;

docker inspect --format '{{.State.Pid}}' alwaysup

_El output del comando es el process ID (2474) _

Para matar el proceso principal del contenedor desde afuera se ejecuta el siguiente comando (solo funciona en linux)

Kill  2474

Yo en windows ocupo el comando: docker stop <ID>,
en remplazo a kill

No sabía como ejecutar la conexión en Docker Windows, y encontré que se utiliza el prefijo winpty:

winpty docker exec -it hardcore_lederberg bash

en Windows puedes matar el proceso desde la GUI

a esta clase le tomaras mayor sentido si es que has tomado algun curso de linux

curso: administracion de servidores linux, hablan de prcesos, mandar a segundo plano un proceso, matarlo, etc

Todo iba tan bien, pero por que meter comandos que nisiquiera se comenta para que sirve --format ‘{{.State.Pid}}’. Solamente pudo poner docker stop y evitarnos la ansiedad

Hice un script que automatiza algunas de las cosas que vimos hoy: Link.

Ok, para Linux parece importante poner el -9, traté de matar el proceso sin la opción -9, pero no funcionaba, funcionó hasta que le puse dicha opción 🤔
.
Se me hace curioso ver cómo al ser una misma máquina Linux (tanto el host como el contenedor), Docker es capaz de ligar directamente los procesos de la máquina host con los de la máquina en Docker, pero cuando no es el mismo S.O, se virtualiza 🤔
.
Lo que me lleva a preguntarme, ¿Docker también es capaz de hacer eso con diferentes distribuciones de Linux?, ¿o también acaba virtualizando? jaja

En dado caso que no le funcione el comando kill por si solo, pueden usar el comando sudo (o el equivalente para la distro) y luego kill ID_Contenedor Ósea:

sudo kill -9 ID_Contenedor

sudo kill -9 PID para terminar el proceso en linux

Es increible docker, corrí Ubuntu y despues le instale Vim y Node

docker run -it node

Ya adentro hice lo siguiente

touch index.js
apt-get update
apt-get install vim
apt-get install node
node index.js

• para matar procesos en linux
  kill -9 PID

La operación kill no mata el proceso del contenedor, al igual que en Mac, en el ubuntu linux que uso no funcionó, o no como es mencionado, pero agrego mi observación para si a los demás también les pasa

Un contenedor es un proceso, a partir de las imágenes ejecutamos contenedores

–tail >> este comando indica que se va a poner a la cola/final del proceso principal

¿Y si se apaga la maquina pero no el Main Process? 😛

docker inspect --format '{{.State.Pid}}' alwaysup

11. Ciclo de vida de un contenedor
Cómo se a hablado en otras clases anteriores un contenedor es un conjunto de procesos que se ejecutan de manera aislada. Cuando se instala una distribución de linux, esta no tiene un proceso principal activo de manera predeterminada, es por este motivo que el contenedor no estará activo de manera predeterminada. La idea de tener un proceso principal (Main process) encendido es que nos permita mantener un ciclo de vida de un contenedor activo y poder salir y entrar del bash sin que el contenedor se apague. se puede utilizar como estrategia un proceso NoOps
Proceso NoOps
Cuando no tenemos claro que proceso podemos ejecutar para mantener nuestro contenedor activo, es posible ejecutar un proceso NoOps para mantener el contenedor activo también es conocido como agujero negro

Todos son archivos con características especiales
https://es.wikipedia.org/wiki//dev/zero
https://es.wikipedia.org/wiki//dev/null
https://es.wikipedia.org/wiki//dev/full
https://es.wikipedia.org/wiki//dev/random

Iniciar un Main process NoOps en nuestro contenedor linux
Lo interesante de usar esta instrucción es que cada vez que se detenga y reinicie el contenedor siempre ejecutará el comando, esto se debe a que final de esta instrucción le indicamos a nuestra versión de linux que inicie con esta instrucción

$ sudo docker run --name <nombre contenedor> -d <nombre imagen> tail -f /dev/null

Ejemplo:

Iniciar main process NoOps

sudo docker run --name alwaysup -d ubuntu tail -f /dev/null

Verificar que el proceso este activo

sudo docker ps -a 

Ejecutar bash dentro de nuestro contenedor

$ sudo docker exec -it <nombre de contenedor> bash
-i: interactivo
-t: abre la consola

Ejemplo:

sudo docker exec -it alwaysup bash

Filtrar y mostrar el proceso

$ sudo docker inspect --format <criterio de filtro> <nombre de contenedor>

Ejemplo:

sudo docker inspect --format '{{.State.Pid}}' alwaysup

Detener o matar proceso

Primera forma

$ sudo Kill -9  <numero de proceso>
$ sudo Kill   <nombre de contenedor>

Segunda forma

$ sudo docker stop <nombre_contenedor>

Ejemplo
Primera forma

sudo Kill -9  21143
sudo kill alwaysup

Segunda forma

sudo docker stop alwaysup

para matar el proceso en Linus tuve que poner “sudo” al principio del comando, de lo contario no me dejaba matar el proceso.
Ejemplo:
sudo kill -9 13421

El numero “13421” es el Pid del proceso en mi PC

Al kill también puedes usar el name del Container sin necesidad del Process Id

kill <CONTAINER_NAME>

Si intentan activar un contenedor inactivo, se hace con docker start <nombre_contenedor> , ya que docker run siempre creara un contenedor nuevo.

Podemos tambien detener nuestro contenedor con:

docker stop <container_id> 

#Por defecto un contenedor corre mientras el main process esta corriendo y tiene

Algun exite code ya sea 0 o distinto.

- corre un contenedor llamado alwaysup en modo detach y le pasa como comando tail

docker run --name alwaysup -d ubuntu tail -f /dev/null

#Para ver que queda corriendo
docker ps

#Puedo conectarme al contenedor con el siguiente comando
docker exec -it alwaysup bash

#Dentro del container
ps -aux
#podemos ver que esta corriendo el comando tail que es el main process, con PID 1
exit
docker ps
#podemos notar que el container sigue corriendo por que el main process no hizo exit.
#Es decir el comando tail no termino

Retornar el Pid del proceso principal del contenedor

docker inspect --format ‘{{.State.Pid}}’ alwaysup

Matar el proceso desde la maquina anfitriona

kill -9 PID

**Salir del contenedor **

exit

Cada vez que un contenedor se ejecuta, basicamente es un proceso del sistema operativo. Por defecto un contenedor corre siempre y cuando su proceso principal este corriendo, al hacer exit, el proceso se detiene.

Que pasa si quiero correr un ubuntu sin el proceso interactivo y que no se apague?

- -d deetach

docker run --name alwaysup -d ubuntu tail -f /dev/null

Conectarnos al bash del contenedor

docker exec -it alwaysup bash

Este proceso va a seguir funcionando mientras que el proceso principal siga funcionando. La prueba de eso es hacer exit y ver que el proceso sigue funcionando debido a que se cerro el proceso del bash pero no el principal.

Para matar o parar el proceso principal

1. Obtener el process id

docker inspect --format '{{.State.Pid}}' alwaysup

1. Detener en linux

kill -9 'id retornado del comando anterior'

comando para mantener la ejecución del docker

$ docker run --name MiAlias1 -d ubuntu tail -f /dev/null

Levanta el contenedor y lo deja vivo, LO MANTIENE ejecutándose en background hasta que algo suceda o alguien lo detenga manualmente

–name, te permite ponerle un titulo o un alias a tu contenedor para que tenga identidad visual y se diferencie del resto. Te ayuda que los puedas personalizar con el nombre que mas te agrade

-d o también -detach, te permite sostener el contenedor, lo deja ejecutándose fijo y no lo apaga.

-f significa forcefully, forzar algo

$ docker exec -it MiAlias1 bash

Permite ejecutar comandos dentro de un contenedor VIVO, en este jemplo el comando bash

$ docker inspect --format ‘{{.State.Pid}}’ MyAlias1

Te imprime el ID del proceso de ese contenedor que se esta ejecutando en ela maquina Linux anfitriona

Con ese ID lo puedes matar con el comando kill + el ID del contenedor

en windows ya teniendo el PID, docker stop 1621. y lo detiene y se sale.

-ehecutando los comandos:
docker run --name server_ubuntu -d ubuntu tail -f /dev/null

luego ejecuto el segundo para ingresar a la terminal:
docker exec -it server_ubuntu bash
y vemos los procesos que estan correindo:
ps -aux

Un contenedor siempre va a correr un main process, el cual puede ser el default o establecido por nosotros.

Si el main process se apaga el contenedor tambien se apaga

Para los que gusten de usar comandos unix en windows, les recomiendo instalar cygwin, tendrán una terminal con BASH y comandos como grep, ls, y demás

https://www.cygwin.com/

para matar el proceso en docker yo utilice

sudo docker kill CONTAINER_ID

Y para revivirlo use

sudo docker start CONTAINER_ID

Con lo aprendido en la clase levante un ubuntu y le instale git, nano y python.😎😎

sudo docker inspect --format ‘{{.State.Pid}}’ alwaisup sirve para conocer el id del proceso

sudo docker exec -it CONTEINER_ID bash : docker esec nos permite ejecutar comandos dentro de un contenedor

sudo docker run --name alwaisup -d ubuntu tail -f /d ev/null : los comandos que se queremos que se ejecuten se ponen al final de contenedor

Estuve viendo el comando tail -f /dev/null lo esta usando para mostrar las ultimas filas de un texto en este caso con la opción null lo que indica un proceso que se mantiene activo a la espera de texto (o eso entendí), no necesariamente se debe agregar al docker run para mantener el contenedor activo. en mi caso lo mantuve con docker run -dti ubuntu

Con:

_docker rm $(docker ps -aq) _

Borras todos los los contenedores por sus ID

docker inspect --format '{{.State.Pid}}' <container>

1 docker run --name alwaysup -d ubuntu tail -f /dev/null
2
3 docker exec -it alwaysup bash
4
5 docker stop alwaysup

Todo contenedor corre mínimo un proceso que se llama MAIN PROCESS siempre desde el punto de vista del contenedor ese proceso va a tener el id 1, es decir que si detenemos otros procesos en el contenedor diferentes al MAIN, el contenedor no se apaga. Éste sólo se detendrá si detenemos el proceso principal.

yo tuve que usar

<sudo kill -9 #process >

el codigo que me funciono para apagarlo fue este,

sudo kill -9 102087

claro y estoy en linux ubuntu

Ciclo de vida de un contenedor

Crear:

docker create --name <container name> <image name>

Iniciar:

docker start <container name>

Pausar:

docker pause <container name>

Continuar contenedor pausado:

docker unpause <container name>

Detener:

docker stop <container name>

Eliminar:

docker stop <container name>

docker rm <container name>

tener un alias corriendo ubuntu y dentro de ese alias ejecutar el bash para poder tener el Ubuntu normal

Ciclo de vida de un contenedor:

Ejemplo:

• docker run ubuntu tail -f /dev/null —> Para no ejecutar el comando por defecto, le podemos decir que se ejecute y no se apague. La terminal se queda congelada.

• Abrir otra terminal

• docker ps —> para obtener nombre

• docker exec -it <nombre contenedor> bash —> Exec es para ejecutar un comando en un contenedor existente. -it para que sea de forma interactiva.

• ps —> En linux se pueden ver los procesos con ps, solo los de mi sesión.

• ps -fea —> Para ver procesos de todas las sesiones. Docker siempre por defecto le asigna el PID (ID del proceso) 1 al comando que corre con el contenedor, ahi esta la clave de cuando se apaga el contenedor. Todo contenedor tiene un root COMMAND, cuando haga exit se va apagar el contenedor.

• exit —> Salir del contenedor. Puedo hacer 2 cosas:

• docker rm -f <nombre contenedor> Elima brutalmente el contenedor. El -f significa “Si esta corriendo no me importa”

• docker kill <nombre contenedor> Manda una señal de matar el proceso.

Si un contenedor se apaga es porque hubo un error en el proceso root e hizo exit o terminó de hacer lo que tenia que hacer.

# Comando tail que muestra las ultimo lineas de un archivo y con -f (Follow o siguiendo) se queda esperando todos los cambios.
# /dev/null este es hoyo negro -- barril son fondo de linux, todo lo que se envie a este directorio se perdera, por esto el SO se queda ejecutando
docker run ubuntu tail -f /dev/null
# Ejecutar un comando en un contenedor Exec, para que sea interactivo al nombre del contenedor mediante bash
docker exec -it fervent_hopper bash
# el comando muestra lso procesos y el pid 1 siempre es el del contenedor
ps -fea 
--Revisar el PID del contenedor
docker inspect --format '{{.State.Pid}}' alwaysup
kill -9 pid #Para linux funciona
-- Eliminar el contenedor
docker rm -f fervent_hopper
-- Matar el proceso
docker kill fervent_hopper
#Otra forma
docker stop alwaysup

Una alternativa a lo mostrado en clase

# kill PID <-"Process ID"

Solo funciona en Linux, sin embargo si ingresas al mismo container e identifícas el proceso principal con ps y ejecutas el mismo commando “matarás al proceso principal”, por ende para la ejecución del container.

docker exec -it <container> bash

lanza una shell dentro del contender!!
WOW no se imagina cuanto me ha servido

Y aportando “trucos”, podemos crear un contenedor que se autodestruya en N segundos con el comando sleep, ejemplo para 10 minutos: 600 segundos

docker run -d debian sleep 600

De igual modo pueden hacer usar cualquier comando que sea IO blocking para que el contenedor se mantenga en ejecución por ej.

docker run -d debian tail -f /etc/passwd

docker exec: En un comando que ya existe o que esta corriendo ejecutar un proceso.
-it: Modo interactivo, te mete dentro del contenedor
–format ‘{{.State.Pid’}}: Sirve para filtrar tados en el inspect.
kill: Mata a un proceso dentro del contenedor. Si el main process muere, el contenedor igual:(

Cada vez que se inicia un contenedor, en realidad lo que ejecuta es un proceso del sistema operativo. Este proceso (main process o proceso principal del contenedor) es el que determina si el contenedor está funcionando o no. Por defecto, un contenedor se mantiene activo siempre y cuando su proceso principal se mantenga en ejecución.

El proceso principal de un contenedor puede ser sobrescrito o cambiado en el momento de iniciar el contenedor, y eso lo hacemos indicando el proceso a ejecutar seguido del nombre de la imagen del contenedor. Por ejemplo: $ docker run ubuntu tail -f /dev/null. En este caso, el proceso principal de este contenedor no será /bin/bash (que es el proceso principal por defecto de una imagen de Ubuntu) sino que ahora será tail -f /dev/null, que es básicamente un proceso infinito que no hace nada, pero se mantiene siempre en ejecución.

Podemos también enviarle instrucciones a contenedores que existan y que estén en ejecución, a través del commando docker exec. Por ejemplo, si ya tenemos un contenedor Ubuntu en ejecución, podríamos conectarnos a él ingresando a su interfaz línea de comandos con docker exec -ti <nombre_del_contenedor> bash. Con la bandera -ti le indicamos a Docker que nos queremos conectar de manera interactiva, para así poder interactuar con la CLI del contenedor. Cuando cerremos la conexión con el contenedor, éste no se detendrá, porque la instrucción con la que nos conectamos a él no es su proceso principal.

Para ingresar al contenedor:

en proceso secundario

docker exec -it alwaysup bin/bash

Comando Contenedor alwaysup

docker run --name alwaysup -d ubuntu tail -f /dev/null

En resumen...

Para matar un proceso en ubuntu

primero averiguamos el numero del proceso

sudo docker inspect --format '{{.State.Pid}}' alwayup

y luego para matar el proceso con el numero que arroja y la siguiente instruccion

sudo kill -9 15491

sudo docker run --name alwaysup -d ubuntu tail -f /dev/null
sudo docker exec -it alwaysup bash
sudo docker inspect --format '{{.State.Pid}}' alwaysup
sudo kill <numero del proceso>
sudo docker stop alwaysup