Aprende a aprender
En una distrubución debian instalaremos nginx con el comando.
apt install nginxPodemos comprobar que funciona con el comando
ps aux | grep nginx
También podemos visitar la ip de nuestro servidor a través de un navegador web
En instalaciones basadas en debian encontramos el directorio de instalación en /ec/nginx
en aquest tutoria……
En este tutoriar crearemos la típica aplicación web que hace un recuento de visitas.
Construiremos esta aplicación con node js y redis.
Node js será la parte que servirá la aplicación web y redis lo utilizaremos como base de datos para hacer el recuento de vistitas.
Primero vamos a construir la aplicación web.
Para ello crearemos el directori visistas con mkdir visitas y abriremos una instancia de visual studio code en este directorio para empezar a trabajar.
Creamos el ficher package.json con el siguiente contenido.
{
"dependencies": {
"express":"*",
"redis": "2.8.0"
},
"scripts": {
"start": "node index.js"
}
}Crearemos ahora el fichero con el que iniciarà nuestro servidor.
const express = require("express");
const redis = require("redis");
const app = express();
const client=redis.createClient();
client.set('visits',0);
app.get('/',(req,res)=>{
client.get('visits',(err,visits)=>{
res.send('Number of visits is'+visits);
client.set('visits',parseInt(visits)+1);
});
});
app.listen(8081,()=>{
console.log('Escuchado puerto 8081');
});Vamos a crear un dockerfile para la aplicación web, de momento no estará relacionado con redis.
FROM node:alpine
WORKDIR '/app'
COPY package.json .
RUN npm install
COPY . .
CMD ["npm","start"]Como podéis ver es muy similar al de los tutoriales anteriores.
Para construir la imagen ejecutamos docker build .
No olvidemos que podemos etiquetar esta imagen con
dooker build -t enguillem/visitas:latest . (usad vuestro usuario de dockerhub)
Ahora tendremos que pensar de que forma podemos poner en marcha todo esto con otro contenedor que funcione con redis
Si tratamos de arrancar la imagen así como está recibiremos un error de conexión al servidor redis.
Podríamos pensar que ejecutando un contendor con redis descargado de dockerhub ya podríamo funcionar.
Si lo hacemos en otro terminal tendríamos un servidor de redis corriendo
Si ahora volvemos a la imagen montada con Dockerfile y la volvemos a ejectuar seguiremos teniendo el mismo error, no hay una conexión con este contenedor redis.
Estos dos contenedores están totalmente aislados, debemos realizar algún tipo de conexión entre ellos.
Para ello utilizaremos una herramienta para este tipo de conexiones, docker-compose
Es un cliente instalado juntamente con docker
Sirve para ejecutar múltiples contenedores al mismo tiempo
Nos permite automatizar la ejecución de ‘docker run’
Lo que haremos es coger las instrucciones de build i run:
docker build -t enguillem/visits:latest
docker tun -p 8080:8080 enguillem/visits
-----------------------------------------
Las integramos en un --->> docker-compose.yml (sintaxis especial) i el cliente docker-compose se encargará de empaquetarlo todoQue incluirá nuestro docker-compose.yml
version: '3'
services:
redis-server:
image: 'redis'
node-app:
build: .
ports:
- "4001:8081"
Docker compose creará dos contenedore en una misma red, la relación de puertos solamente es para nuestra máquina principal.
Ahora tenemos que modificar el fichero index.js para indicar donde ir a buscar el servidor de redis.
const express = require("express");
const redis = require("redis");
const app = express();
const client=redis.createClient({
host: 'redis-server',
port: 6379
});
client.set('visits',0);
app.get('/',(req,res)=>{
client.get('visits',(err,visits)=>{
res.send('Number of visits is'+visits);
client.set('visits',parseInt(visits)+1);
});
});
app.listen(8081,()=>{
console.log('Escuchado puerto 8081');
});construir los contenedore
docker-compose up
Lo primero que hace docker-compose es crear una red
Podemos ver todo lo que crea docker-compose, y el mesaje final parece que todo está funcionando
Como hemos cambiado el puerto del cliente debemos ir a la siguiente url
Si actualizamos varias veces se incrementa el número de visitas
docker-compose up -d
docker-compose down
En este tutorial veremos como crear un servidor nodejs con docker, para ello seguiremos los pasos siguietes:
Lo primer será crear el directorio donde pondremos nuestro codigo, para ello hacemos lo siguiente
mkdir simpleweb
cd simpleweb
code . (para abrir code en este directorio)A partir de aquí trabajaremos en el terminal de visual studio code
Ahora debemos crear el fichero package.json con este contenido
{
"dependencies": {
"express": "*"
},
"scripts": {
"start": "node index.js"
}
}Lo podéis ver en la imagen siguiente
Ahora creamos el fichero index.js con el siguiente contenido
const express = require('express');
const app = express();
app.get('/',(req,res)=>{
res.send('hola que tal!');
});
app.listen(8080,()=>{
console.log('Escuchando puerto 8080');
});
Lo podéis ver en la imagen siguiente:
Para continuar es importante que verifiquéis que estáis en el mismo directorio
Veamos los paso a realizar para tener una aplicación Node JS funcionando:
Teniendo en cuenta lo que hemos visto en tutoriales anteriores sabemos cual es la estructura de un dockerfile, solo tenemos que aplicarlo en el caso que nos ocupa
Primero creamos el Dockerfile
#imagen base
FROM alpine
WORKDIR /usr/app
#instalamos dependencias
RUN npm install
#comando inicial
CMD ["npm","start"]
Veamos pero que pasa cuando intentamos construir esta imagen.
vemos que tenemos un error
Nos indica que el comando npm no está disponible, no tenemos ninguna copia de npm incluida en la imagen alpine que usamos
De esta forma la imagen es lo suficientemente pequeña para no tener problemas con las descargas.
Tenemos la opción de descargar las dependencias o bien ir a dockerhub y buscar una imagen que nos sirva para nuestro proposito.
En dockerhub hay una imagen oficial para nodejs
En este enlace https://hub.docker.com/_/node veremos que existe una versión de node en alpine, podemos usarla como vemos a continuación.
#imagen base
FROM node:alpine
WORKDIR /usr/app
#instalamos dependencias
RUN npm install
#comando inicial
CMD ["npm","start"]
Si ahora construímos la imagen ya no tenemos el problema de que npm no esté instalado, peró no tenemos ningun código para nuestra aplicación en nuestro contenedor y obtenemos el siguiente error:
Debemos pues de copiar el código que hemos hecho anteriormente en nuestro contenedor.
Para copiar nuestro código debemos indicarlo en nuestro Dockerfile con el comando COPY
COPY ./ ./La primera ruta se refiere a nuestro disco local y la segunda a la imagen que estamos construyendo, para ello el Dockerfile queda como sigue
#imagen base
FROM node:alpine
WORKDIR /usr/app
#instalamos dependencias
COPY ./ ./
RUN npm install
#comando inicial
CMD ["npm","start"]podemor ver como queda
I ahor ya no tenemos el erro anterior
Vemos que ya tenemos una id para poder arrancar nuestro contenedor, pero no la hemos etiquetado, pues lo hacemos ahora
Y ahora sí ejecutamos el contenedor
Tenemos el servidor arrancado, pero que pasa cuando vamos a visitar la web en cuestión?
No hay una correlació de puertos entre nuestra máquina donde se ejecuta docker y nuestro contenedor.
De alguna manera debemos indicar que cuando querramos acceder al puerto 8080 de nuestra máquina local esta petición se debe redireccionar al puerto 8080 de nuestro contenedor.
Docker no tiene ningún problema para acceder a internet, pero debemos mapear las entradas hacia nuestro contendor.
Esto lo indicamos cuando ejecutamos el contendor de la siguiente forma:
docker run -p 8080:8080 <nombre-imagen>
en nuestro caso
docker run -p 8080:8080 enguillem/simplewebY ahora ya funciona nuestra aplicación node js
Una cosa a tener en cuenta es que el puerto de origen puede cambiar, el de destino no, a no ser que lo cambiemos en la aplicación.
Cada vez que hacemos un camibio en el codig, por ejemplo cambiamos index.js para que salga otro mensaje, no tenemos otra forma de hacer cambios que con todo un redeploy del proyecto.
Tambien sucede que cada vez que hacemos un deploy la instrucción COPY copia toda la estructura del proyecto.
Esto para proyectos grandes puede llegar a ser muy pesado.
Por tanto haremos un cambio para solo copiar lo imprescindible, que en este caso será package.json
COPY ./package.json ./
Nuestro Dockerfile quedará así
De esta forma solo se copiará este fichero cuando se realicen cambios en el.
En la línia 10 añadimos ahora un COPY ./ ./ que se encargará de copiar el resto de ficheros cuando se produzcan cambios.
Antes de empezar debemos editar el ficher /etc/default/docker y añadir nuestros servidores de dns como se indica en la siguiente imagen.
Debemos reiniciar docker con
sudo service docker restart
Para poder construir imagenes crearemos un Dockerfile con el que podremos:
Crearemos una imagen que ejecute un servidor de redis.
Primero creamos un directorio mkdir redis-server, entramos en el cd redis-server y abrimos visual studio ejectuando el comando code .
Una vez abierto visual studio code pasaremos a crear el fichero Dockerfile
Los comentarios indican lo que se va a hacer a cada paso, y a continuación podéis ver el contenido de las instrucciones
Ahora solamente tenemos que construir la imagen, para ello usaremos el terminal que nos ofrece visual studio code para ejecutar el comando:
docker build . (no olvidar punto final)
En este caso vemos en el último mensaje la id de nuestro contenedor, y como hemos visto en el primer tutorial debemos usar esta id para ejectuar el contendor.
Para parar usamos Ctrl+C
FROM alpine : indica la imagen base a descargar, si queremos usar debian podríamos FROM debian
RUN apk add –update redis : en este caso indica a la imagen que actualice los paquetes e instale el servidro redis
CMD [«redis-server»] : indica que comando ejecutar una vez se inicie el contenedor
Escribir un dockerfile es como iniciar un ordenador sin sistema operativo e ir indicándole que pasos debe hacer para instalar un programa, como por ejemplo google chrome.
Para este ejemplo concreto lo que haríamos seria:
Estos serían los pasos que se indicarían en la receta para instalar chrome.
Es muy similar a lo que hemos hecho con nuestro dockerfile:
Utilizamos alpine como imagen base ya que es una distribución linux que se adapta a nuestras necesidades en este caso, del mismo modo que un usuari elige usar Windows, linux o macOS
En este caso es muy fácil instalar redis en alpine con el comando apk add –update redis
Esta instrucción indica a docker que debe construir una imagen a partir de un fichero de configuración des del directorio donde nos encontramos, por eso el punto (.) (contexto)
El contexto es el conjunto de ficheros y carpetas que contendrán la iformación necesaria para construir la imagen que usaremos para crear nuestros contenedores.
En nuestro caso la salida del comando docker build . nos da lo siguiente
Step 1/3 : FROM alpine
---> 14119a10abf4
Step 2/3 : RUN apk add --update redis
---> Using cache
---> 092f34ede7a1
Step 3/3 : CMD [ "redis-server" ]
---> Using cache
---> 55e275efe6ae
Successfully built 55e275efe6aeCada paso (step) hace referencia a una instrucción del dockerfile, en este caso los pasos utilitzan la cache ya que no hemos realizado cambios en el dockerfile.
En cada paso intermedio se utiliza una id que representa un contenedor temporal que se guarda para el siguiente paso, se realiza un snapshot para seguir con el proceso.
En el último paso tenemos una imagen modificada con todos los pasos anteriores y con un comando a punto de ejectuar.
En el ejemplo anterior hemos visto que se usaba la cache ya que hemos mostrado una segunda ejecución del comando build.
Si ahora modificamos el dockerfile para instalar otra dependencia, por ejemplo gcc, quedaría como sigue:
Al ejectuar ahora docker build, en el paso 3 y siguientes ya no se usa la cache al ser una instrucción nueva
Esto modifica los contenedores intermedios y se construyen de nuevos
En los pasos 1 y 2 se sigue usando la cache ya que no ha habido cambios.
Si ahora ejecutamos de nuevo docker build . veremos que todos los pasos están en cache
Mejor poner los cambios lo más abajo posible para evitar tener que reconstruir toda la imagen
Para ejectuar una imagen debemos usar docker run <id-de-la-imagen>
En el caso anterior sería docker run e200d85efe4a
Para no tener que estar recordando número en hexadecimal largos lo que podemos hacer es etiquetar una imagen cuando la construyamos.
La convención para etiquetar una imagen es la siguiente
enguillem/redis:latest (lo primero es nuestra id de docker la obtenmos de https://hub.docker.com/) el nombre del proyecto en este caso redis y la versión, podemos latest en este caso, auque podríamos poder un número.
La instrucción para construir una imagen etiquetada sería:
docker build -t enguillem/redis:latest . (no olvidar el punto)
Ahora podemos ejecutar un contenedor usando el nombre de la imagen:
Tutorial de instalación https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-debian-10
docker run <nombre-de-la-imagen>Ejemplo
docker run hello-world
Para sobreescribir el comando inicial de una imagen lo hacemos con esta instrucción
docker run <nombre-de-la-imagen> comando
ejemplo
docker run busybox echo hola mundo
Podemos sobreescribir el comando por ejemplo con un ls
docker run busybox ls
En este caso podemos ver el contenido del sistema de ficheros de nuestro contenedor.
Si intentamos ejecutar los comandos sobre la imagen hello-world que hemos instalado al principio recibimos un error ya que ni echo ni ls estan instalador en la primera imagen
Para listar los contenedores en ejecución lo hacemos tal como sigue:
docker ps (solamente los que están en ejecución)
docker ps -all (se ven todos los contenedores, aunque no estén en ejecución)Cuando ejectuamos un contenedor pasa lo siguiente:
docker run = docker create + docker start
crear un contenedor: docker create <nombre-de-la-imagen>
ejectuar un contenedor: docker start -a <id-del-contenedor>
Primero miramos que contenedores tenemos instalados con docker ps –all
Con el comando docker start -a <id> volvemos a ejecutar el contenedor apagado
En este caso no podemos sobreescribir el comando inicial.
Con docker system prune eliminamos los contenedores apagados
para obtener los logs de un contenedor:
docker logs <id-del-contenedor>
veamos otro ejemplo
Primero creamos un contendor con busybox que no se va a detener
Para detenerlo tenemos dos opciones
docker stop <id-del-contendor> (termina el proceso de manera normal)
docker kill <id-del-contenedor> (no realiza ningún tipo de cierre)Stop da tiempo para guardar cambios, encambio kill no hace ningún trabajo adicional.
Es mejor enviar la señal de stop
Primero ejecutamos un contenedor de redis
docker run redis
Ahora tenemos que abrir un segundo terminal con un cliente de redis no podremos acceder ya que no estamos ejecutando el cliente dentro del contenedor.
Para ello debemos ejecutar el cliente dentro del mismo contenedor.
La estructura del comando sería la siguiente:
docker exec -it <id-del-contenedor> <comando>Com docker ps -all vemos la id del contenedor
Ahora ejecutando docker exec -it <id> redis-cli el cliente de redis se ejecutaria dentro del contenedor.
Los comandos redis se ejecutarían en el contenedor
Si la opción -it no tenemos interactividad con el nuevo comando.
Primero tenemos que obtener la id de nuestro contenedor redis con docker ps -all
Luego ejecutamos docker exe -it <id-contenedor> sh y obtenemos un shell para ejecutar comando.
Podríamos ejectuar el cliente de redis
y para salir haríamos Ctrl+c
Para salir del shell del contenedor hacemos exit
Para iniciar con un shell usemos el siguiente comando:
docker run -it busybox shSi se abren dos contenedores con este comando están aislados, son máquinas diferentes, a no ser que los conectemos de alguna forma.