Deploy de una app con Moleculer y React desde Docker

Buenos días blogueros, hoy vamos a ver como subir una aplicación con Moleculer como backend y React como frontend  desde Docker.

Lo primero que tendremos que hacer es instalar docker en nuestro servidor para ello tan solo tenemos que ejecutar los siguientes comandos:

En mi caso vamos a usar los de debian, pero en la documentación hay para otras distribuciones.

Docker

Primero actualizaremos el sistema:

$ sudo apt-get update

Luego instalaremos las dependencias necesarias para docker:

$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg2 \
    software-properties-common

Añadimos una clave oficial de Docker:

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

Comprobamos si se ha creado correctamente:

$ sudo apt-key fingerprint 0EBFCD88

Y añadimos a nuestro sources.list el repositorio de docker:

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

Ahora tan solo instalamos los paquetes:

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Una vez instalado todo si hacemos un docker hello world podremos comprobar si se ha instalado correctamente:

$ sudo docker run hello-world

Ahora vamos a necesitar instalar una herramienta necesaria para ejecutar una imágen docker:

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

Ahora le damos permisos:

sudo chmod +x /usr/local/bin/docker-compose

Por último necesitaremos correr una imágen de nats ya en nuestro docker recien instalado.

docker run -p 4444:4444 nats -p 4444

Bien llegados a este paso ya tenemos todo lo necesario para correr nuestro docker con una imágen de nuestra aplicación.

En mi caso voy a descargarme un proyecto que tengo en Git.

Una vez en nuestro servidor vamos a crear tres archivos en la carpeta donde esté nuestro frontend y backend.

Uno de ellos será Dockerfile el cual tendrá el script para ejecutar todos los comandos necesarios para instalar y correr la aplicación, en mi caso sería algo tal que así:

FROM node:8

#ENV NODE_ENV=production

RUN mkdir /app
WORKDIR /app

COPY . .

RUN cd frontend && npm install && npm run build 

RUN cp -r frontend/build backend/build  

RUN npm config set unsafe-perm true

RUN cd backend/resources && npm install -g prisma && prisma generate

RUN cd backend && npm install

WORKDIR /app/backend

CMD ["npm", "start"]

Son simplemente comandos de bash, nada más, primero creamos la carpeta /app donde compiamos el frontend e instalamos npm y lo ejecutamos, luego copiamos la carpeta que crea con run build en el backend, instalamos prisma y generamos los esquemas, accedemos al backend, instalamos y hacemos un npm start.

El siguiente archivo que vamos a necesitar es docker-compose.env el cual tiene:

SERVICEDIR=services

PORT=4101

TRANSPORTER=nats://nats:4222

El único comando que nos interesa es PORT donde pondremos el puerto donde vayamos a ejecutar la aplicación y el de TRANSPORTER en el cual pondremos donde apunta nuestro servidor nats.
Y por último el archivo docker-compose.yml:

version: "3.0"

services:

  api:
    build:
      context: .
    image: conduit
    env_file: docker-compose.env
    environment:
      SERVICES: api
      PORT: 4101
    links:
      - nats
    depends_on:
      - nats
    labels:
      - "traefik.enable=true"   
      - "traefik.backend=api"
      - "traefik.port=4101"
      - "traefik.frontend.entryPoints=http"
      - "traefik.frontend.rule=PathPrefix:/"

  users:
    build:
      context: .
    image: conduit
    env_file: docker-compose.env
    environment:
      SERVICES: users
    links:
      - nats
    depends_on:
      - nats

  contact:
    build:
      context: .
    image: conduit
    env_file: docker-compose.env
    environment:
      SERVICES: contact
    links:
      - nats
    depends_on:
      - nats

  nats:
    image: nats
    ports:
      - "4222:4222"

  traefik:
    image: traefik
    command: --web --docker --docker.domain=docker.localhost --logLevel=INFO --docker.exposedbydefault=false
    ports:
      - "4101:80"
      - "3001:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /dev/null:/traefik.toml

Donde pondremos el puerto al que apuntaremos (el mismo que en el archivo docker-compose.env), los servicios que tengamos declarados en nuestra aplicación de Moleculer, el puerto donde tengamos el nats correindo y el Traefik el cual es una aplicación que distribuye las distintas peticiones de la aplicación.

Una vez tengamos todo configurado tan solo tendremos que ejecutar docker-compose up --build -d
dentro de la carpeta donde estén nuestros archivos de configuración de docker. Esperamos a que se monte la imágen i si accedemos a nuestra NUESTRA_IP:EL_PUERTO_SELECCIONADO, podremos ver nuestra aplicación corriendo ya en producción.