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…

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.

En mac corrí este comando para apagar el contenedor

docker kill alwaysup

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/

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

Otra forma de que el contenedor no se apague es

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

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

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

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

gustavo@~$ kill 6228
kill: (6228) - Operación no permitida

Pero si pude con:

docker kill alwaysup

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

*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 ver la Pid , también lo pueden hacer de esta menera

docker inspect alwaysup | grep -i Pid

• 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

Hola! Esta es una solución para quienes no les funcione con el tail en windows:
Soy nuevo en esto, así que no sé si sea la mejor solución a esto, pero lo que hacemos con tail -f es para hacer follow de las últimas líneas de un archivo, en este caso, según lo que leí, en Linux existe un archivo llamado null, en /dev/null, el cual es un archivo especial que contiene nada, un infinito nada, entonces eso permite mantener el output de manera infinita, ya que usamos la flag -f para seguir las últimas nuevas líneas con el null, entonces como en windows no existía esto, y como estaba usando la git bash, hice lo siguiente, espero les sirva, ya que es una buena práctica poner como proceso principal a ese archivo nulo, así no gastas CPU al leer nada, y a la vez tienes un proceso infinito hasta que quieras matarlo a tu voluntad.
Ahora sí, perdón por la verborrea, aquí está la solución
Si ponen “tail -f $null” en la git bash, verán que les aparece una lectura infinita, dado a que es una variable automática con el valor que buscamos que haga lo mismo que el archivo “/dev/null” en linux (https://docs.microsoft.com/en-us/powershell/scripting/learn/deep-dives/everything-about-null?view=powershell-7.2) (Pd: Para salir tan solo pon [ctrl]+[c])
Entonces, la solución a esto en windows sería poner

docker run --name probandoesto -d ubuntu tail -f $null

Espero les sirva! Aunque no sé si sea la mejor solución, pero al ver el proceso con “ps” y “top”, se puede ver que funciona y no gasta CPU! Saludos!

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

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

Tampoco funciona en un WSL de Ubuntu…

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

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

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

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

en Windows,
para los que no puedan mantener el contenedor activo, solo quiten el / detrás del dev, que quede así dev/null.

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

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

A mi me funciono docker kill NOMBRE_CONTAINER
ubuntu

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

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

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

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

Estoy trabajando en Ubuntu y no me sirvió el comando kill , no se porque no funciono

El curso es buenisimo, estoy aprendiendo mucho, pero la verdad siento que quizas le hagan falta algunas cosas mas introductorias, como instalar una imagen sin correrla inmediatemente, o como cambiarle el nombre a cada imagen, puede que en otras clases lo veamos, pero primero lo primero, igual, felicitaciones, muy buen curso

Estoy feliz porque me funcionaron los coamndos en Play with Docker 😉

Si por alguna razón quieren parar todos sus contenedores, pueden usar:

docker stop $(docker ps -aq)

docker stop detiene los contenedores, mientras que con $(docker ps -aq) se envían como parámetros los ID de todos los contenedores.

curioseando me funciono detener varios contenedores con una sola linea listando los nombres de los que esten corriendo.

docker stop alwaysup1 alwaysup2 alwaysup3

😄

Que clase tan interesante y rica en conceptos

tambien se puede correr

docker kill alwaysup

Para matar el proceso docker kill <nombre>

Para los de windows el comando para “matar” el contenedor en ejecución es:
docker kill "nombre de tu contenedor"
ejem:
docker kill alwaysup

**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'

Yo uso ubuntu pero no me dejo correr:

$ kill  -9  proces_id
bash: kill: (4648) - Operación no permitida

Tuve que utilizar:

$ sudo kill  -9  proces_id

Para que me permitiera hacer el proceso

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.

no es necesesario poner el container_id
tambien pueden hacerlo con
sudo docker kill names
sudo es en caso de linux

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

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

Si quieres parar el contenedor lo puedes hacer de dos maneras.

1. Matar el proceso con Kill:

   docker kill alwaysup
   

2. Eliminar forzadamente el contenedor:

   docker rm -f 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

en Windows puedes matar el proceso desde la GUI

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

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

docker inspect --format '{{.State.Pid}}' 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>

mucha gente esta confundiendo matar el proceso con el contenedor; lo que se busca es matar el proceso para que se apague el contenedor. pilas !

Una forma menos complicada de filtrar el json y obtener el pid es:

docker inspect alwaysup | grep Pid

Tener en cuenta que si lo estas corriendo nativamente en linux probablemente el comando

kill -9 (pid del proceso) 

no te funciono si no estas en el usuario root, para eso puedo agregar el sudo antes del comando para tener los permisos necesarios

sudo kill -9 (pid del proceso)

🌀 Ciclo de vida de un contenedor

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 encendido a menos que falle el main.

Por si alguien se pregunta que hace el comando tail -f:

  -f, --follow[={name|descriptor}] muestra a medida que el fichero crece;
                                     sin opción significa 'descriptor'

Lo que quiere decir que el contenedor se quedara corriendo mientras espera nuevas lineas en la entrada indicada

¿Se pueden activar subtitulos ?

Considero que este curso esta omitiendo mucho los comandos importantes o no se toma su tiempo en explicar mas detallado cada uno, para ser un curso de docker básico hasta el momento es muy pobre las explicaciones, por ejemplo el stop, run, etc

Si estás ejecutando kill para matar el proceso de docker del ejemplo. Me sirvió hacer las siguientes sentencias:

docker kill id_container
docker container prune

#aunque lo más probable es que me haya servido:

docker rm id_container

Correr Kali Linux

Me gusta mucho Kali, y sus beneficios. Así que si a alguien más le surgió la duda aquí los dos comandos simples para hacerlo.

docker pull docker.io/kalilinux/kali-rolling

docker run --tty --interactive kalilinux/kali-rolling

Ciclo de vida de un contenedor

Cada vez que un contenedor se ejecuta, ejecuta un proceso del S.O.

Para correr un contenedor y que no se detenga, agregamos ‘-d’ (detach)

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

Luego podemos ver el process id y detenerlo:

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

sudo kill -9 <Pid>

Comandos:

docker run --name alwaysup -d ubuntu => nombre de la imagen
docker exec -it alwaysup bash => ejecutar un comando o un proceso en un contenedor existente
docker stop alwaysup => parar un proceso de docker

Para iniciar un contenedor ya creado

Docker start [name]

Ciclo de vida de una aplicación usando docker:

Y ciclo de vida de un contenedor:

Excelente curso y muy clara la explicación de los temas!!!

Con este comando pueden ejecutar un contenedor existente.

docker start  `docker ps -a -q --filter "name=nombre_contenedor"`

El profe explica bien pero vi un video practicamente igual y me gusto, se los comparto:

https://www.youtube.com/watch?v=JXZXVPRtyiM&t=302s

“tail -f /dev/null is a command that runs endlessly and doesn’t use any CPU because nothing can be read from /dev/null and we are asking for an endless read from it.” 🙌

Importante tomar en cuenta esto para futuros overrides.
La forma de cambiar el main process se debe cambiar el entrypoint, tomando en cuenta esta linea usada en esta clase:

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

//Le estamos enviando como parametro la imagen
{ ubuntu }

//Como segundo parámetro 
{ tail -f /dev/null } 

//este segundo parámetro es más que todo una técnica para dejar un proceso vivo en este container. 
//Recuerda el comando 
{ tail } 
// es para leer lineas de archivo plano y con la bandera 
{ -f } 
//hacemos que el sistema este a la escucha de nuevos cambios en este archivo. 

.
Entender el sistema de comandos de docker
Ejemplos de tail

Si en el comando

docker exec -it <container_name> bash

No les funciona el bash pueden cambiarlo por sh.

docker es mejor sobre linux. gracias profe

Al correr una instacia docker ejecuta un proceso principal y si este finaliza el contenedor también, este proceso se visualiza en la columna COMMAND cuando ejecutamos docker ps

Para levantar un contenedor y que este siga vivo podemos cambiar el proceso principal y desatacharlo de la ejecucion docker, esto es con:

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

al final despues del nombre de la imagen se escribe el comando/proceso que se quiere se ejecute, en este caso tail -f /dev/null el cual no hace nada pero no termina

Para poder entrar y ejecutar comandos en bash es con:

docker exec -it <nombre-instancia> bash

A mi me funcionó también con:

docker kill alwaysup

Saludos

Quede algo perdido en esta clase!

me tope con el problema de que no podia pausar (```
docker stop

[](https://docs.docker.com/engine/install/linux-postinstall/)

Teniendo que añadir el usuario al grupo de docker (en lo particular me sucedia con usuario local y usuario root)

importante: de la docu de docker "If testing on a virtual machine, it may be necessary to restart the virtual machine for changes to take effect."

Obtener el proceso id de la máquina nativa

docker inspect --format '{{.state.pid}}' alwaysup

obtenemos el id y para matar el mismo:

kill -9  <id>

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

Para terminar el proceso es:

sudo kill -9 PID

El PID se obtiene de lo que indica Guido

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

comando para mantener la ejecución del docker