En este post te enseño a crear una base de datos en postgreSQL y pgAdmin una herramienta de interface gráfica para poder administrarlo, todo esto con docker.

#### Pre - Requisitos

- Docker

#### PostgreSQL

Empezamos creando nuestro contenedor que creara nuestra base de datos postgreSQL.

```bash
docker run -p 5432:5432 \
	--name postgresql-container \
	-e 'POSTGRES_PASSWORD=mysecretpassword' \
	-v ${PWD}/data:/var/lib/postgresql/data \
	-d postgres
```

Entendiendo el comando anterior:

- `-p` para publicar el puerto expuesto del contenedor, el primer valor es el puerto del tu host que puede ser cambiado si es que ya tienes usando actualmente el `3000` para otro proceso.
- `—-name` es el nombre de tu contenedor.
- `-e` para poder definir variables de entorno, una de las que definimos es para la contraseña ase de datos que es `POSTGRES_PASSWORD`
- `-v` creamos un volumen, importante para poder persistir la información de nuestros datos dentro de nuestro `file system` y no solo dentro del contenedor, para ello usamos `${PWD}/data` para indicarle en la carpeta data del directorio actual.
- `-d` para poder correr nuestro contenedor en segundo plano.
- Y por ultimo `postgres` que es la imagen que estamos usando

#### pgAdmin

Ahora la siguiente herramienta te permitirá visualizar tus datos sin la necesidad de instalar ningún IDE

```bash
docker run -p 80:80 \
	--name pgadmin-container \
	-e 'PGADMIN_DEFAULT_EMAIL=user@domain.com' \
    -e 'PGADMIN_DEFAULT_PASSWORD=SuperSecret' \
    -d dpage/pgadmin4
```

Entendiendo el comando anterior:

- `-p` como vimos anteriormente te permite publicar el puerto expuesto del contenedor y de la  misma forma puedes cambiar el primer valor si lo estas ocupando para otro proceso.
- `—-name` es el nombre de tu contenedor.
- `-e` como vimos anteriormente te permite crear variables de entorno.
    - `PGADMIN_DEFAULT_EMAIL` y `PGADMIN_DEFAULT_PASSWORD` son necesarias para poder iniciar con `pgAdmin`
- `-d` para poder correr nuestro contenedor en segundo plano.
- y por ultimo `dpage/pgadmin4` que es la imagen que estamos usando.

Podemos ver nuestra herramienta GUI directamente en el navegador `http://localhost`, ingresaremos  con los valores de nuestras variables de entorno declaras, `PGADMIN_DEFAULT_EMAIL` y `PGADMIN_DEFAULT_PASSWORD`.

![](/pgadmin/home.png)

Ahora registraremos un server.

![](/pgadmin/create-server-1.png)

Y por consiguiente agregaremos todos los valores de conexión.

![](/pgadmin/create-server-2.png)

Entendiendo que valores colocar:

- `Host`: Colocar la ip de tu host, puedes obtenerlo con `ifconfig`.
- `Port`: Puerto `5432` por defecto.
- `Maitenance database`: Base de datos a conectarnos, por defecto `postgres` .
- `Username`: Por defecto esta con el usuario `postgres`.
- `Password`: En password colocar el valor de nuestra variable de entorno `POSTGRES_PASSWORD`.

___

#### Siguientes pasos

Podemos automatizar el manejo de nuestros comandos de docker usando `docker-compose` de la siguiente forma:

#### Pre - Requisitos

- Docker Compose

Creamos un fichero llamado `docker-compose.yml` en el directorio actual de nuestro proyecto:

```yml
version: '3.1'

services:
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: mysecretpassword
    ports:
      - 5432:5432
    volumes:
      - ./data:/var/lib/postgresql/data

  pgadmin:
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: user@domain.com
      PGADMIN_DEFAULT_PASSWORD: SuperSecret
    ports:
      - 80:80
```

Se definen nuestros 2 contenedores que queremos crear, uno para nuestra base de datos `postgreSQL` y otro para `pgAdmin` con todos los parámetros que inicialmente colocábamos en nuestros comandos de `docker run`.

Ahora solo debemos ejecutar el siguiente comando:

```bash
docker-compose up -d
```

Con esto ya tenemos de forma operativa nuestra base de datos `postgreSQL` y nuestro `pgadmin`.

___

#### Nota

Ya que todos nuestros comandos lo estamos ejecutando en segundo plano con el flag `-d` probablemente no se en algun caso puede que los contenedores no corran sus servicios de forma inmediata, si desea saber que esta ocurriendo en cada contenedor puede ejecutar el siguiente comando:

```bash
docker-compose logs
```

o directamente consultar los logs de cada contenedor individualmente.

```bash
docker logs <hash_conteiner>
```

___

Si te gusto esta pequeña guía y tienes alguna duda no dudes en escribirme.

PostgreSQL + pgAdmin con Docker

Dive es una herramienta que te permitirá poder explorar el interior de nuestras imágenes docker.

#### Características

- Explorar todas las capas que contiene nuestra imagen también comandos usados en el Dockerfile y el tamaño de cada capa.
- Indicar los diferentes cambios que se realizaron en la imagen, ejemplo: si agregamos código fuente de nuestra aplicación en la imagen.
- También nos provee un puntaje de eficiencia de nuestra imagen.
- Ciclos rápidos de análisis después de una construcción.

#### Instalación
___


##### Homebrew

```bash
brew install dive
```

##### Arch

```bash
yay -S dive
```

##### Ubuntu/Debian

```bash
wget https://github.com/wagoodman/dive/releases/download/v0.9.2/dive_0.9.2_linux_amd64.deb
sudo apt install ./dive_0.9.2_linux_amd64.deb
```

#### Uso

```bash
dive <image_hash>
```

#### Estructura

![](/dive/structure.png)

- Sección 1: encontraremos los comandos que se usaron en nuestra receta, tamaño de la capa seleccionada y en la sección 2 podemos ver el contenido interno de dicha capa. Puedes moverte entre la sección 1 y 2 con `tab`.
- Sección 3: Detalles específicos de nuestra imagen como:
  - Tamaño total.
  - Puntaje de eficiencia.
  - Espacio potencialmente desperdiciado.
  - Una lista de directorios posiblemente no usados.

#### Entorno CI

También se puede usar en un entorno de integración continua solo hay que agregar su variable de entorno `CI=true`.

```bash
CI=true dive <image_hash>
```

Además también podemos configurar umbrales en un archivo de configuración llamado `.dive-ci`

```yml
rules:
  # Si la eficiencia se mide por debajo de X%, mark as failed.
  # Expressed as a ratio between 0-1.
  lowestEfficiency: 0.95

  # If the amount of wasted space is at least X or larger than X, mark as failed.
  # Expressed in B, KB, MB, and GB.
  highestWastedBytes: 100KB

  # If the amount of wasted space makes up for X% or more of the image, mark as failed.
  # Note: the base image layer is NOT included in the total image size.
  # Expressed as a ratio between 0-1; fails if the threshold is met or crossed.
  highestUserWastedPercent: 0.20
```

considerando el ejemplo anterior con un tamaño de desperdicio de 100KB, tendríamos la siguiente salida

![](/dive/ci.png)

#### Conclusión

Excelente herramienta que me ayudó mucho a la hora poder optimizar imágenes docker, sin duda una herramienta a tomar en cuenta para este tipo de tareas y también a la hora de poder tener control sobre sobre la eficiencia de nuestra imagen.

Wilson Flores

Sotfware Engineer FullStack at PedidosYa

All Posts

PostgreSQL + pgAdmin con Docker

Dive, herramienta para analizar imágenes docker