# Docker y Kubernetes (DPL)
## Docker
Es una plataforma de software que le permite desarrollar, probar e implementar aplicaciones rápidamente.
Empaqueta software en unidades estandarizadas llamadas contenedores que incluyen todo lo necesario para que el software se ejecute, incluidas bibliotecas, herramientas de sistema, código y tiempo de ejecución.
Con Docker, puede implementar y ajustar la escala de aplicaciones rápidamente en cualquier entorno con la certeza de saber que su código se ejecutará.
## Contenedores
Nos permite encapsular nuestras aplicaciones junto con sus dependencias. Con esto garantizamos que nuestra aplicación se va a ejecutar sin depender de la máquina en la que se instala.
Además permite redimensionar fácilmente los recursos asignados a la aplicación según se incrementa la demanda de los usuarios.
Un contenedor de Docker es una imagen de Docker instanciada (en ejecución).
### Ventajas
- Los contenedores aíslan las aplicaciones entre sí, a menos que las conectes de manera explícita. Es importante destacar que esto proporciona una capa adicional de seguridad, ya que tus aplicaciones no se ejecutan directamente en un sistema operativo host.
- Ofrecen a los desarrolladores la capacidad de crear entornos predecibles que están aislados de otras aplicaciones.
- Incluyen dependencias de software que la aplicación necesita.
- Se garantiza que todo esto sea uniforme, independientemente de dónde se implemente la aplicación.
- Todo esto se traduce en productividad: los desarrolladores y los equipos de operaciones de TI dedican menos tiempo a depurar y diagnosticar diferencias en los entornos y más tiempo a ofrecer funcionalidades nuevas para los usuarios.
- Se pueden ejecutar prácticamente en cualquier lugar.
- La gran popularidad del formato de imagen de Docker para los contenedores ayuda aún más con la portabilidad.
- Los contenedores virtualizan la CPU, la memoria, el almacenamiento y los recursos de red al nivel del SO.
## Imagen
Una imagen de Docker es una plantilla de solo lectura que define su contenedor.
La imagen contiene el código que se ejecutará, incluida cualquier definición para cualquier biblioteca odependencia que el código necesite.
El proceso habitual es descargar una imagen e iniciar uno o más contenedores a partir de esta imagen.
A partir de un contenedor se puede crear una imagen.
Recuerda que una imagen es como una foto estática de un momento determinado de un contenedor.
## Persistencia de Datos
Docker simplifica enormemente la creación de contenedores, y eso lleva a tratar los contenedores como un elemento efímero, que se crea cuando se necesita y que no importa que se destruya puesto que puede ser reconstruido una y otra vez a partir de su imagen.
Pero si la aplicación o aplicaciones incluidas en el contenedor generan datos y esos datos se guardan en el propio contenedor, en el momento en que se destruyera el contenedor perderíamos esos datos.
Para conseguir la persistencia de los datos, se pueden emplear dos técnicas:
- Los directorios enlazados: La información se guarda fuera de Docker, en la máquina host.
- Los volúmenes: La información se guarda mediante Docker, pero en unos elementos llamados volúmenes, independientes de las imágenes y los contenedores.
### Volúmenes
Los volúmenes son la mejor solución cuando la información es generada por el propio contenedor y los directorios enlazados pueden ser más adecuados cuando la información no es generada por ningún contenedor.
Son independientes de los contenedores, por lo que también podemos conservar los datos aunque se destruya el contenedor. La ventaja frente a los directorios enlazados es que pueden ser gestionados por Docker. Otro detalle importante es que el acceso al contenido de los volúmenes sólo se puede hacer a través de algún contenedor que utilice el volumen.
## Contenedor vs Máquina Virtual
En lugar de virtualizar la pila de hardware como en las máquinas virtuales, los contenedores realizan la virtualización en el nivel del sistema operativo, con varios contenedores que se ejecutan directamente en el kernel del SO.
Varios contenedores pueden compartir el mismo kernel.
Los contenedores son mucho más livianos, se inician con bastante más rapidez y usan una fracción de la memoria en comparación con el arranque de todo el SO.
## Comandos
### Primeros comandos
- Ver estado del servicio Docker
```bash=
$sudo systemctl status docker
```
- Información del servicio
```bash=
$docker info
```
- Para ver todas las opciones
```bash=
$docker
```
- Ayuda sobre una opción o subcomando
```bash=
$docker subcomando -help
```
- Ver todos los contenedores activos
```bash=
$docker ps
```
- Ver todos los contenedores
```bash=
$docker ps -a
```
### Docker HUB
- Repositorio extenso de imágenes, algunas de ellas oficiales. Nosotros también podemos subir nuestras propias imágenes.
- Para ver las imágenes desde línea de comando:
```bash=
$docker search
```
### Buscar y descargar imágenes
- Buscamos una imagen
```bash=
$docker search <imagen>
```
- Descargamos la imagen
```bash=
$docker pull <imagen>
```
- Para poder ver las imágenes descargadas en nuestro ordenador
```bash=
$docker images ls
```
### Iniciar un contenedor
- Creamos un nuevo contenedor a partir del la imagen, se ejecuta y se sale.
```bash=
$docker run <imagen>
```
- Lo mismo, pero antes de salir del contendor se ejecuta un comando dentro del contenedor.
```bash=
$docker run <imagen> ls
```
- Ejecutamos el contenedor a partir de la imagen y abrir una terminal de comandos interactiva para poder ejecutar todos los comandos que queramos. El contenedor sigue “vivo” hasta que salgamos.
```bash=
$docker -it run <imagen> sh
```
- Docker run con muchas opciones
```bash=
$docker run --name <nombre> -d -p 8080:80 -v "$(pwd)":/var/www/html <imagen>
```
- La opción **--name** nos permite dar un nombre al contenedor.
- La opción **-d** permite lanzar el contenedor en segundo plano.
- **-p 8080:80** Direcciona el puerto 80 del contenedor al puerto 8080 de la máquina real.
- **-v** “$(pwd)”:/var/www/html monta el directorio actual en / var/www/html del contenedor.
- php:7.4-apache Una imagen con php7.4 y apache2
---
- Reiniciar un contenedor
```bash=
$docker start -a -i <idcontenedor>
```
- Compartir el directorio actual de la máquina real “$(pwd)” con un directorio dentro del contenedor.
```bash=
$docker run -it -v “$(pwd)”:<directorio> <imagen>
```
- Creamos una imagen a partir de un DockerFile
```bash=
$docker build -t <nombre-imagen> <directorio-donde-está-dockerfile>
```
### Directorios enlazados
- Cree un nuevo contenedor que enlace al directorio
```bash=
$docker run -d -P --name=<nombre> --mount type=bind,source=<fuente>,target=<directorio-contenedor> <imagen>
```
### Volúmenes
- Creamos un contenedor montado en un volumen
```bash=
$docker run -d -P --name=<nombre> --mount type=volume,source=<nombre-volumen>,target=<directorio-apuntado> <imagen>
```
- Listamos los volúmenes
```bash=
$docker volume ls
```
- Copìamos un ficherod dentro del directorio de un volúmen
```bash=
$docker cp <fichero> <volúmen>:<directorio>
```
- Borramos un volúmen
```bash=
$docker volume rm <volúmen>
```
### Ver contenedores
- Ver los contenedores de nuestro ordenador.
- **docker ps** ver los contenedores en ejecución.
- **docker ps -a** ver todos los contenedores.
- Ejecuta el contenedor: **docker run -it alpine sh**.
- Desde otra terminal, ejecutamos: **docker ps**.
Debemos estar viendo al menos un contenedor ejecutándose.
- Consultar información de un contenedor: **docker inspect id_contenedor**.
- Dirección ip: **docker inspect**.
### Eliminar contenedores e imágenes
- Docker proporciona un solo comando que eliminará cualquier recurso que estén pendientes:
```bash=
$docker system prune
```
- Para eliminar adicionalmente los contenedores detenidos y todas las imágenes no utilizadas:
```bash=
$docker system prune -a
```
### Docker Compose
Es una herramienta que facilita el uso de contenedores.
En un fichero con formato YAML definimos los contenedores. Pudiendo definir uno o varios.
- **docker-compose up -d**: se ejecuta los contenedores en segundo plano.
- **docker-compose stop**: Para los servicios.
*Ejemplo docker-compose.yml*
### Dockerfile
Un dockerfile es un fichero de texto que permite definir una imagen.
## Kubernetes
### ¿Qué es?
- Es una plataforma portable y extensible de código abierto para administrar cargas de trabajo y servicios.
- Facilita la automatización y la configuración declarativa.
- Tiene un ecosistema grande y en rápido crecimiento.
- Google liberó el proyecto Kubernetes en el año 2014
### Uso
- Definimos nuestro entorno de desarrollo con un fichero DockerCompose en donde podemos definir varios contenedores y como se relacionan entre ellos:
- Puertos de los contenedores mapeados al host
- Volumes para compartir carpetas con los contenedores
- Usamos DockerFile para configurar imágenes a partir de imágenes oficiales.
- Cuando queremos desplegar nuestra aplicación, definimos la imagen de despliegue en donde, por ejemplo, no se debe incluir librerías de depuración como Xdebug.
- Subimos nuestra imagen a un repositorio.
- Finalmente, desplegamos nuestra aplicación en la nube usando Kubernetes.
### Aplicaciones monolíticas vs microservicios
### ¿Qué es un cluster?
- Es un conjunto de máquinas de nodos que ejecutan aplicaciones en contenedores.
- Si ejecutas Kubernetes, estás ejecutando un clúster.
- Un clúster posee al menos un nodo de trabajo y un nodo maestro.
- El nodo maestro es el encargado de mantener el estado deseado del clúster y de controlar.
- Los nodos de trabajo son los que realmente ejecutan las aplicaciones y las cargas de trabajo.
### Funcionalidades de Kubernetes K8s
- Es una plataforma para poder construir un ecosistema de componentes y herramientas que hacen más fácil el desplegar, escalar, y administrar aplicaciones.
- K8s es una abrevación que se obtiene al reemplazar las ocho letras "kubernete" con el número 8.
### Conceptos básicos en K8s
- Un clúster es conjunto de nodos.
- **Nodo maestro**: máquina que controla los nodos de Kubernetes.
- **Nodo de trabajo**: máquinas que realizan las tareas solicitadas y asignadas. Donde se ejecutan los contenedores.
- **Espacio de nombre**: clúster virtual. Los espacios de nombre permiten que Kubernetes gestione varios clústeres dentro del mismo clúster físico.
- **Pod**: conjunto de uno o más contenedores que se ejecuta en un nodo.
- Es el objeto más pequeño y simple de Kubernetes.
- **Servicio**: forma de exponer una aplicación que se ejecuta en un conjunto de pods como un servicio de red.
- **Volumen**: directorio que contiene datos, al que pueden acceder los contenedores de un pod.
### Arquitectura cluster K8s
- Al menos 1 master (panel de control)
- Uno o varios nodos (máquinas)
- Cada nodo ejecuta uno o varios pods
- Cada pods ejecuta uno o varios contenedores
- Da igual en qué nodo concreto se ejecutará los contenedores.
### Pods
- Los pods se crean, se reproducen y mueren.
- No es importante conocer en que nodo se ejecuta un pod.
- Los pods tienen asignados ips que pueden ser reasignados. Por lo que sus ips pueden cambiar.
###### tags: `DAW` `DPL` `UT5`
Sign in with Wallet
Connect another wallet