NODE.JS Y DOCKER

Docker es una software open-source que lo que permite asilar o enpaquetar aplicaciones y sistemas en contenedores, similar como lo hace la virtualizacion pero de manera mas eficiente y liviana.

Instalar las dependencias 

Ya sea que estes comenzando o estes trabajando con un proyecto, la confuguracion de las dependencias sera crucial al momento dev desplegar la aplicacion.Si vas a crear un nuevo proyecto prueba el comando

npm init

Te pedira informacion relacionada con la aplicacion, como el nombre, la version, el tipo de licencia entre otras cosas. Ahora solo debes especificarle los paquetes que necesita. En este caso, se necesita a express solo para este proyecto.

npm install --save express //version completa o
npm i -s express //version reducida

O en el caso de trabajar con previamente creado, y contenga un archivo package.json en este caso solo con el packete de express similar a este. 

package.json
{
  "name": "bytefate_app_node",
  "version": "1.0.0",
  "description": "Node.js Bytefate App on Docker",
  "author": "name ",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Crear el servicio web, en mi caso se vera algo asi.

app.js
'use strict';
const express = require('express');

// Constants
const PORT = 8080;

// App
const app = express();
app.get('/', (req, res) => {
  res.send('Welcome to Byte Fate');
});

app.listen(PORT, HOST);
console.log(`Running on http://localhost:${PORT}`);

Si hay algunas retricciones por parte del firewall, con este comando habilitara la operacion del puerto donde estara corriendo la aplicacion.

sudo ufw allow 8080

 

 Dockerfile 

Ahora a lo que vinimos Dockerfile es un archivo que se le va a indicar en secuencia, al contenedor el comportamiento una vez se ejecute. Lo primero es escoger la imagen, hay distintas distribuciones dependiendo del tamaño de las imagenes, en este ejemplo se utilizara la mas ligera con la version 14 que hasta el momento es la version recomendada

FROM node:14-alpine

Lo siguiente es prepara la ruta para guardar los archivos dee la aplicacion y en lo posible limitar los permisos asignados al contenedor como buena practica

RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app

Luego se asigna el espacio de trabajo.

WORKDIR /home/node/app

Copia el archivo en el directorio que se le asigno en el comando anterior

COPY package*.json ./

Se asegura que los archivos de la aplicacion este con el usuario node

USER node

Descarga las dependencias de la aplicacion

RUN npm install

Copia los archivos y le asigna como propietario el usuario node

COPY --chown=node:node . .

Espone con el puerto asignado el contenedor

EXPOSE 8080

Inicia la aplicacion, con los parametros que se le han pasado.

CMD [ "node", "app.js" ]
 

El archivo queda algo asi.

Dockerfile
FROM node:10-alpine
RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
WORKDIR /home/node/app
COPY package*.json ./
USER node
RUN npm install
COPY --chown=node:node . .
EXPOSE 8080
CMD [ "node", "app.js" ]

Nota: En dockerfile si tienes varios cmd solo el ultimo se ejecutara. Cuando se trabaja con git, es conveniente que los anexes tambien a este archivo, el .git y gitignore. .dockerignore

.dockerignore
node_modules
.dockerignore
Dockerfile

 

 Ahora a crear la imagen, con el siguiente comando.

docker build -t username/bytefate_app_node .

La -t es para colocarle un tag, que la usaremos para reconocer las imagenes personalizadas y es usual que primero se coloque el nombre de usuaro de dockerhub, seguido del tag de la aplicacion(username/tag). Y el punto (.) es para ejecutarlo en el contexto actual. Para listar las imagenes que tenemos usa el comando.

docker images

Estando todo listo, es hora de ejecutar la imagen con el siguiente comando

docker run --name bytefate_app_node -p 80:8080 -d username/bytefate_app_node

lo que hace el --name es darle un nombre al contenedor que esta corriendo, -p para redirigir el trafico a otro puerto de ser necesario y -d es para correr en segundo plano.Para verificarlo es facil, con el siguiente comando podras ver todos los contenedores que estan corriendo.

docker ps

 

 Bueno eso es todo por el momento, espero que les haya sido de utilidad y nos veremos pronto.

Basico - Docker II

DOCKER BASICO

 Requisitos: 

• Tener Instalado docker en su entorno de preferecia, o siga el siguiente enlace.
  
• Primeros pasos con docker

 

Cliclo de vida de los Contenedores

Arrancar en segundo plano

docker run -d <opciones> <image_name>

Con el comando -d corre el contenedor en segundo plano, cuando termine su proceso muera el contenedor, en opciones puede hacer port forwarding para que el contenedor se conecte por ese puerto.

docker run -di <image_name>

La opcion -i permite que el contenedor aun al terminar su proceso siga vivo o esperando.

Arrancar en segundo plano y acceder a el
Existiendo ya un contener accediendo el comando exec

docker exec -it <container_name_or_id> terminal

Puede usar sh o bash como terminal pasandola como parametro

Parar un contenedor

docker stop <container_name_or_id> 

Eliminar una imagen

docker rmi -f <image_name_or_id> 

Eliminar una imagen forzado

docker rmi <image_name_or_id>

Eiminar un contenedor

docker container rm <container_name_or_id>

Eiminar un contenedor forzado

docker container rm -f <container_name_or_id>

Dockerfile

Es un archivo en el que secuencialmente ejecuta una tareas dentro de una imagen docker, desde definir variables de entorno hasta instalacion de paquetes y ejecucion de aplicaciones, todo esto definido en un archivo llamado Dockerfile.

- FROM: Recibe el nombre de la imagen que se usara de base en el contenedor.

- RUN: Ejecuta un comando sobre la capa actual del contedor y almacena el cambio.

- CMD: Proporciona un valor predeterminados durante ejecucion del contenedor, si existen mas de una instruccion CMD solo se ejecutara la ultima dentro del Dockerfile.

- LAVEL: Añade metadatos a traves de llave - valor.

- EXPOSE:Informa a docker en que puerto estara escuchando el contenendor en el tiempo de ejecucion pero aun no estan accesibles.

- ENV: Establece de forma clave - valor el variables de entorno.

- COPY:  Copia nuevos archivos, directorios o url al contenedor, por defecto lo establece como usuario root. Como buena practica se deberia utilizar --chown = <user>:<group> para darle propiedades de propietario tambien aplicables a ADD.

- ADD: Copia nuevos archivos, directorios o url al contenedor (recomendable no usarlo).

- ENTRYPOINT: Configura un contenedor que se ejecutara como un ejecutable.

- VOLUMEN: Crea un montaje dentro del contenendor que accede a otros contenedores o el host nativo.

- USER: Crea un user en el sistema que puede interactuar con los comando RUN, CMD y ENTRYPOINT.

- WORKDIR: Crea un directorio de trabajo.

- ARG: Crea una argumentos utilizados en tiempo de ejecucion del dockerfile.

- ONBUILD: Ejecuta un disparador cuando una imagen es usada por otra.

- STOPSIGNAL: Envia una señal de salida al contenedor, llamando al sistema.

- HEALTHCHECK: Comprueba el status del contenedor del docker en intervalos de tiempo.

- SHELL: Permite anular la shell por defecto, es comunmente utilizada en sistemas windows donde hay 2 shells nativas (cmd, powershell).

Una vez terminado el Dockerfile lo siguiente es crear la imagen y luego ejecutar la imagen recien creada

EJEMPLO

FROM ubuntu:16.04
CMD ["/bin/echo","Hello World ByteFate!]

 para construir la imagen debe se utiliza el siguiente comando

#docker build -t <tag> .
 docker build -t saludo:1.0 .

Lo que traduce es que se esta creando una imagen, -t indica que le pasa el nombre a la imagen por convenciones se utiliza name:version y el punto es el contexto actual, osea donde se encuentra el archivo Dockerfile.

#docker run --options <image_name>
docker run --name bytefate_saludo saludo:1.0

Con la operacion run arranca un contenedor y las opciones se le pasan como parametro al contenedor, como una variable de entorno, un puerto de escucha, etc.

ref: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

ref: https://docs.docker.com/engine/reference/commandline/docker/

PRIMEROS PASOS CON DOCKER - Docker I

 

 

Docker es una instancia de ejecucion de imagen, que permite de cierta manera virtualizar un entorno, combinando solo las librerias y configuracion necesarias para su ejecucion,haciendo mas facil el encapsulamiento portatil para un programa.

 REQUISITOS: Tener en el sistema operativo instalado docker. Si aun no lo tienes sigue este enlace.

COMENZANDO

Pero antes unos cuantos conceptos que ayudara a entender un poco mejor a Docker

Image: Es un tipo de plantilla para un contenedor donde estan los componentes basicos para funcionar.

 

Container: Es una instancia de una imagen, permitiendo encapsular un programa completo y hacerlo portable para cualquier otra maquina que tenga docker.

Docker Hub: Es un servicio de repositorio donde estan almacenadas muchas de las imagenes publicas, las imagenes mas confiables son las que fueron posteadas por las mismas empresas y son catalogadas como imagenes oficiales. Las imagenes varian de tamaño dependiendo de que base de sistema utilicen la mas pequeña es alphine-linux y llega a pesar 5mb.

DockerCompose: Es utilizado como archivo de configuracion para crear las imagenes, en este archivo se escribe el conjunto de instrucciones que se quiere ejecutar de forma sincrona.

 

Verificar la version de docker 

docker -v

Descargar una imagen

Descarga una imagen de docker hub explicitamente, o se descarga automaticamente cuando hace llamado a docker run

docker pull alpine

Hacer un echo

Al ejecutarse el contenedor mostrar en consola un "Hola Mundo"

$docker container run alpine echo 'Hola Mundo'

Abrir un archivo

Mostrara el contenido del archivo que incluye le mensaje del dia, que se muestra cada vez que se inicia sesion. 

$ docker container run alpine cat/etc/motd

 

Muestra las imagenes locales

$ docker images

Lista de Contenedores Activos

$ docker container ls
//tambien con el comando
$ docker ps

Lista de Contenedores 

Si has llegado hasta este punto podras ver un par de contenedores de alpine, fueron contenedores que se ejecutaron cumplieron con su proposito y se detuvieron.

$ docker container ls -a
//tambien con el comando
$ docker ps -a

Con esta breve introduccion de algunos conceptos y ejemplo ayudara a enterder la interaccion de los contenedores en un proximo post.

 

ref:https://docs.docker.com/reference/

 

COMO INSTALAR DOCKER EN UBUNTU 20.04

Docker

es un sistema opensource que busca empaquetar, gestionar el despliegue de las aplicaciones con los recursos necesarios para que funcione, en algo llamado contenedores. Así creando una especie de máquinas virtualizadas super ligeras que favorece la implementación rápida y modular de un software en cualquier equipo que posea Docker.

Prerequisitos

Es necesario contar con una máquina con sistema operativo Ubuntu 20.04 con permisos de usuario. Además de actualizar la lista de paquetes del sistema y unos complementos de HTTP que apt requiere.

 sudo apt-get update
 sudo apt install apt-transport-https ca-certificates curl software-properties-common

Instalacion

Lo primero que se hace es descargar la llave GPG para verificar la firma de los paquetes

 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Luego descargar el repositorio de Docker

 sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"

Se actualiza los paquetes del sistema

 sudo apt update

Ahora se instala la versión comunity de Docker

 sudo apt install docker-ce

Solo falta verificar si el servicio de Docker está corriendo

 sudo systemctl status docker

Docker-Compose

Si piensa trabajar con varios contenedores a la vez y que se comuniquen entre ellos, es recomendable instalar Docker-Compose

 sudo curl -L "https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

En el siguiente post, profundizaremos un poco más Docker.