Ver el código de «Usuario:ManuelRomero/ProgramacionWeb/Docker/Conceptos»

<!--{{Usuario:ManuelRomero/ProgramacionWeb/Docker/nav}}-->
<div class=parrafo>/

*{{Docker/conceptosGenerales}}


===Instalar Docker===
<br />
{{MRM_Web|Title=Instalar docker|
 https://docs.docker.com/install
Para ubuntu
 https://docs.docker.com/install/linux/docker-ce/ubuntu/
Para windows
 https://docs.docker.com/docker-for-windows/install/
}}

;Pasos a realizar
1.- Desinstalar versiones antiguas
<source lang=bash>
sudo apt-get remove docker docker-engine docker.io containerd runc
</source>
2.-Ahora vamos a instalar usando el repositorio de docker para ubuntu
<source lang=bash>
 sudo apt-get install  ca-certificates   curl   gnupg-agent  lsb-release
</source>
3.- Añadimos la clave GPG oficial de docker
<source lang=php>
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

</source>
4.- Añadimos el repositorio stalbe. Si quieres pañadir uno nightly o test, modifica la palabra estable por el tipo de vesión que desees instalar
<source lang=bash>
 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</source>
{{Tip|'''''lsb_release -cs'''''; '''-c''',  '''codename''', para mostrar el nombre de código de la distribución, '''-s''', '''short''' para solo mostrar el valor del nombre}}
5.- Actualizamos el índice de los paquetes apt e instalamos docker
<source lang=bash>
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io
</source>

;Ahora para poder ejecutar docker el usuario actual sin usar sudo
*Agragamos el usuario actual ( u otro si queremos que sea otro) al grupo de docker
<source lang="bash">
 sudo usermod -a -G docker $USER
</source>
*Cambiamos el grupo de usuarios actual al grupo de usuarios de docker
<source lang=bash>
   newgrp docker
</source>

*Para ver todos los comando
<source lang=bash>
 docker help
</source>

===Contenedor Vs Imagen===
*Este es un concepto importante que puede quedar claro si vemos la imagen anterior
*La imagen es el fichero que nos va a permir instalar esta '''especie de máquina virtual'''.
*Es como el iso para instalar el sistema operativo
*El contenedor es el sistema corriendo con el cual podemos interactuar. Se instala a partir de una imagen
*Lo bueno que tiene docker es que a partir de un contenedor podemos crear una imagen con todo el software que tenga ese contenedor. Cuando volvamos a desplegar la imagen creada en otro contenedor, tendremos disponible todo el software incluido. En la sección siguiente realizaremos estas acciones.
*{{Docker/Registro}}
===Acciones concretas===
;Crear un contenedor a partir de una imagen del repositorio<br />
1.-A partir de la imagen '''''ubuntu:latest'''''<br />
2.-El contenedor que se quede activo disponible interactivamente '''''-ti'''''<br />
3.-El nombre del contenedor lop doy explícito  '''''-name idioma'''''<br />
4.-La crearemos con un volumen mapeando el directorio /var/www/html del contenedor con /var/www/idioma de mi anfitrión '''''-v /var/www/html:/var/www'''''<br />

 {{MRM_Puntos clave|Title=Crear un contenedor|
;Se puede crear de diferentes formas
*'''''run'''''. Con este comando es la forma mas básica de crearlo
*'''''Dockerfile''''': Se crea el fichero y con el comando built podemos construir un contenedor a partir de la especificación del fichero
*'''''docker.compose.yml''''',  un fichero que me va a permitir crear/levantar varios contenedores especificando todas mis necesidades
}}
<source lang="bash">
  sudo docker run --name idioma -v /var/www/idioma:/var/www/html -ti ubuntu:latest
</source>
*Verificamos que se han creado los dos directoris (tanto el anfitrión (idioma) como en el contenedor (www/html)

;En el contenedor
[[Archivo:mapeo_dir_docker1.png]]
;En el anfitrión
[[Archivo:mapeo_dir_anfitrion1.png]]
*Mira los permisos (lo ha creado docker,   docker siempre actúa como root)
*los modificamos
<source lang=bash>
sudo apt-get chown manuel:www-data /var/www/idioma
</source>

*para ver más opciones disponibles 
<source lang=bash>
 sudo docker help run
</source>
;Ver los contenedores del sistema
<source lang="bash">
  sudo docker ps -a
</source>
;Ver los las imágenes   del sistema
<source lang="bash">
 sudo docker images
</source>

;Modificar un contenedor
*Una vez abierto el contenedor podemos proceder a instalar cosas.
*Para la práctica necesitamos instalar una serie de paquetes (si necesitamos más los ponemos)
{{MRM_Clave|Title=Paquetes a instalar|
;apache y php
 apt-get install apache2 php libapache2-mod-php
;gettest (luego comentaremos)
}}
{{MRM_Clave|Title=Paquetes a instalar|
;net-tools y vim
*Estos paquetes los instalo para poder ver la ip y como editor 
 apt-get install net-tools vim
}}
{{Tip|Si tenemos dudas podemos mirar el apartado de instalación del primer tema del curso, también si queremos instalar java, xdebug u otros paquetes}}
;Crear una imagen en local a partir de un contenedor
 {{MRM_Puntos clave|Title=Crear una imagen|
;commit}}
*Igual que en git, 
 docker [opciones] nombre_container [nombre_img:tag]
<source lang="bash">
docker commit -m "Con webservice" -a "Manuel Romero<dir@dom.com>" idioma img_idioma:v1
</source>
[[Imagen:commit_img1.png]]<br />
*Y vemos cómo se ha creado
[[Imagen:img_creada1.png]]<br />


=====Arrancar un contenedor =====

*Una vez cerrado el contenedor (no parado), éste sigue estando disponible
*Una vez que cerremos el contenedor, mientras no lo destrullamos, podremos disponer de él, aunque apaguemos la máquina, digamos que se queda pausado
;Crear una imagen en local a partir de un contenedor
 {{MRM_Puntos clave|Title=Arrancar un contenedor|
;start
;exec
}}

*Para usarlo hay que realizar dos acciones
<source lang=bash>
~ ➭  docker start  dwes
dwes
~ ➭  docker exec -ti dwes /bin/bash 
root@496b9ba15066:/#
</source>



:Crear un contenedor a partir de una imagen en local
*Con el comando run, pero especificando la imagen local
:Crear un contenedor con un volumen lógico a partir de una imagen en local
*Para ello usamos el parámetro -v
<source lang=bash>
 docker run --name nombre_contenedor_nuevo -v /var/www/iternova:/var/www -dti nombre_imagen
</source>

====Realziar una copia de un contenedor en un fichero====
*Podemos hacerlo de diferentes maneras. una sencilla es usar el comando export / import
[[archivo:export_docker.png]]
[[archivo:import_docker.png]]
====Exportar e Importar====
;Exportar 
*Se exportará un contenedor a una imagen y se almacenará en un fichero tar.
*De esta forma la imagen contendrá todos los servicios instalados en el contenedor.
*Recordad que los contendios de los volúmenes no forman parte del contenedor, aunque se pueda acceder desde ellos. Físicamente estarán en el directorio especificado en el volumen de la máquina anfitriona.
{{MRM_Actividad|Title=Pasos a seguir para exportar una imagen|
1.- Paramos la imagen
<source lang=bash>
docker stop nombre_contendor
</source>
2.- Exportar la imagen
<source lang=bash>
docker export nombre_contendor -0 nombre.tar
</source>
*Esto nos creará un fichero con nombre '''''nombre.tar''''' que contendrá la imagen
}}
;Importar
*Se importará una imagen a partir de un fichero tar que la contiene
*Una vez importada la imagen podremos crear un contenedor con los parámetros que consideremos.
*El contenedor creado, contendrá todos los servicios que tenía el contenedor  a partir del cual se creó la imagen en el fichero tar (contenedor que exportamos previamente).
{{MRM_Actividad|Title=Pasos a seguir para importar una imagen|
2.- Importar la imagen
<source lang=bash>
docker import nombre.tar nombre_imagen:tag
</source>
*Esto nos creará una imagen que la llamamos como consideremos a partir del fichero nombre.tar 
*Ahora podemos comprobar que tenemos la imagen
<source lang=bash>
docker images
</source>
*Ahora podemos crear un contendor, por ejemplo siguiendo con la clase
<source lang=bash>
docker run --name nombre_contenedor_que_creo -v c:\Users\web:/var/www/html -p 80:80 -dti nombre_imagen:tag
</source>
}}


*{{Docker/comandosImágenes}}
*{{Docker/comandosContenedor}}
*{{Docker/volumenesYCopiarContenedorHost}}
{{MRM_Web|Title=Docker composer|
 https://medium.com/@carlos.compains/creando-un-entorno-de-desarrollo-con-docker-a56790af6271
}}

===Dockerfile===
{{MRM_Web|Title=Referencia de DockerFilw|
 https://docs.docker.com/engine/reference/builder
}}
*Hasta ahora hemos creado un '''''contenedor''''' a partir de una '''''imagen''''' usando el comando '''''run'''''
*Una vez que tenemos el contenedor le agregamos los servicios que necesitamos
*Para no perder el trabajo, de ese contenedor creamos una imagen y ya lo tenemos disponible para crear nuevos contenedores con todos los servicios instalados



*Es un '''''fichero de texto''''', que me permite crear '''''una imagen''''' a partir de otra, y añadir una serie de comandos para instalar a esa imagen, aplicaciones, servicios, librerías diversas con el objetivo de construirme una imagen para lanzar un contenedor personalizado a mis necesidades.
*Una vez creado el fichero, lo ejecutaremos y crearemos la imagen con el comando '''''buld'''''
*Si el fichero está en el directorio actual, lo ejecutaremos con el comando '''''punto'''''
*Para ejecutar la máquina ejecutamos
<source lang=bash>
docker build .
</source>
;Estructura del fichero 
<source lang=bash>
 # comentarios
 INSTRUCCIONES argumentos
</source>
En un fichero dockerfile tendremos dos tipos de líneas
#comentarios (líneas que empiezan por '''''#''''')
#Sentencias líneas que tiene una instrucción con una serie de argumentos para ejecutarlas
##Por se recomienda poner las instrucciones en mayúsculas
====Instrucciones====
;FROM
 FROM <imagen>
 FROM <imagen>:<tag>
 FROM <imagen>@<digest>
*
*Es la primera instrucción
*Especifica la imagen base de la que parte la instalación que queremos hacer
* En esta página puedes encontrar imágenes base de las cuales partir (hay miles)
*En el FROM se puede especificar de forma opción el tag o digest (sirve para especificar la imagen, como por ejemplo la versión).
*Lo primero que tenemos que especificar es la imagen de la que partimos '''''instruccion FROM'''''
{{Ejemplo|
<source lang=bash>
;imagen en base a ubuntu 14.04
FROM ubuntu:14.04
</source>
<source lang=bash>
;imagen en base a debian
FROM debian:stable

</source>

}}
;MAINTAINER
 MAINTAINER <name>
*Especifica el autor de la imagen y su correo
MAINTAINER Manuel Romero <ManuelRomeroMiguel@gmail.com>
;RUN
 RUN <command>
 RUN ["ejecutable", "parametro1", "parametro2"]

*Ejecuta cualquier comando en la imagen que estamos usando. El resultado de la ejecución se puede tomar para el siguiente paso en el dockfile, por ejemplo si ejecuto la instalación de apache, en el siguiente comando puedo contar que apache ya está instalado
*Es un comando muy utilizado.
*Si usamos apt-get install especificaremos el flag -y para que no haga falta que sea interactivo y tome la decisión por defecto
*Añadimos a nuestro fichero las siguientes librerías
<source lang=bash>
#Ahora empezamos a instalar todos los paquetes necesarios

==Otros aspectos==
*Instalar un contenedor como un servicio
 https://blog.marcnuri.com/docker-configurando-contenedor-servicio-linux/
 https://onthedock.github.io/post/170920-autoarranque-de-contenedores/
</div>