DEV Community: João Vitor

Docker for beginners: Creating Database Containers

João Vitor — Thu, 28 Mar 2024 15:03:12 +0000

In this article, I will provide some examples of how to create database containers using Docker.

The focus of this article is to assist beginners in using Docker in their projects, addressing questions about creating docker-compose or Dockerfile.

As a reference for the most popular databases, I used the top 9 from the Stack Overflow survey of 2023.

Summary

PostgreSQL
MySQL
SQLite
MongoDB
Microsoft SQL Server
Redis
MariaDB
Elasticsearch
Oracle

PostgreSQL

In our Dockerfile, it will be quite simple. We will use the PostgreSQL image in version 16 and expose port 5432 so that it is accessible by our container.

FROM postgres:16

EXPOSE 5432

Let’s add the database container to our services and assign a name to it, in this case, postgres_db.

services:
  database:
    container_name: postgres_db

In the build tag, we will indicate where our Dockerfile is located, which will be used to configure our Postgres container.

    build:
      context: .
      dockerfile: Dockerfile.postgres

In the context, we use the dot to indicate that the Dockerfile is located in the same directory as the docker-compose.

As PostgreSQL uses the default user postgres, we will only add a password for our user in the environment section.

    environment:
      POSTGRES_PASSWORD: 12345678

Now we need to add the communication ports between the host machine and the container, this will create a connection between the two, making it possible to access the database that was created in the container.

    ports:
      - "5432:5432"

Creating volumes is optional, but it's an interesting thing to do when we're using databases. It allows for data persistence in our container, and even if it's destroyed, we can recreate the container with the data intact from the volume. This is a useful feature for maintaining data consistency and durability.

    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
    postgres_data:

Finally, we will create a Network. They are used to facilitate communication between our services. For example, let’s say you want to create a Compose that includes Postgres and pgAdmin. To facilitate interaction between them, we add both to the same network to assist in communication (Example here).

    networks:
      - mynet

networks:
  mynet:
    driver: bridge

Docker-compose

version: '3.8'

services:
  database:
    container_name: postgres_db
    build:
      context: .
      dockerfile: Dockerfile.postgres
    environment:
      POSTGRES_PASSWORD: 12345678
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - mynet

volumes:
  postgres_data:

networks:
  mynet:
    driver: bridge

MySQL

For the MySQL Dockerfile, we will make the same configuration as PostgreSQL, with the difference that we will expose the default port of MySQL.

FROM mysql:8.3

EXPOSE 3306

The docker-compose will follow the same structure as the Postgres compose, with the difference that in the environment section more fields will be added besides the user’s password.

    environment:
      MYSQL_ROOT_PASSWORD: 12345678
      MYSQL_DATABASE: mydb
      MYSQL_USER: admin
      MYSQL_PASSWORD: admin123

The MYSQL_ROOT_PASSWORD field, as the name suggests, will be the password for the root user. Do not confuse it with the MYSQL_PASSWORD field, which is the password for the user defined in the MYSQL_USER field. The MYSQL_DATABASE field is the name of the database that will be created when building the container. You can create other databases after the container is created using MySQL commands or a database client, such as DBeaver (Example here).

Docker-compose

version: '3.8'

services:
  database:
    container_name: mysql_db
    build:
      context: .
      dockerfile: Dockerfile.mysql
    environment:
      MYSQL_ROOT_PASSWORD: 12345678
      MYSQL_DATABASE: mydb
      MYSQL_USER: admin
      MYSQL_PASSWORD: admin123
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - mynet2

volumes:
  mysql_data:

networks:
  mynet2:
    driver: bridge

SQLite

SQLite is different from the other databases mentioned here. It is a disk-based database, which means it stores the data generated in a file on the system itself and does not depend on a server, like the other databases presented. Generally, the files are saved with the .db extension.

It is widely used in mobile applications, mainly on Android, due to its presence on many devices.

Dockerfile

For the SQLite Dockerfile, we will use an image of a Linux distribution called Alpine, known for its lightness, which makes it a great option for Docker containers.

FROM alpine:3.19

RUN apk add --no-cache sqlite

WORKDIR /database

In this Dockerfile, we install SQLite in our container and create a directory called "database", where we will execute our SQLite commands and save the databases created.

Docker-compose

The SQLite Compose will follow a structure similar to that of Postgres and MySQL, but with some differences.

The first difference is in the volumes, where we will specify the directory in which the volume will be mounted, allowing for more efficient manipulation of the container data.

    volumes:
      - ./sqlite_data:/database

The second difference is the tail -f /dev/null command. Since SQLite is a disk-based database and does not have a server to keep the container active, we use this command to keep the container running.

command: ["tail", "-f", "/dev/null"]

The tail command is used to display the last lines of a file, while the -f argument is used to specify the file that the command should follow waiting for new lines. By specifying /dev/null, which contains nothing, the command will not display any content in the terminal, thus keeping our container active so that we can use the SQLite commands in the terminal.

version: '3.8'

services:
  database:
    container_name: sqlite_db
    build:
      context: .
      dockerfile: Dockerfile.sqlite
    volumes:
      - ./sqlite_data:/database
    networks:
      - mynet3
    command: ["tail", "-f", "/dev/null"]

volumes:
  sqlite_data:

networks:
  mynet3:
    driver: bridge

MongoDB

MongoDB is a NoSQL database, unlike the others presented so far, which were SQL, that is, relational databases. Mongo is a document-oriented database and is widely used for its flexibility, scalability, and ease of manipulation.

Dockerfile

Our Dockerfile will follow the same pattern as the others. We will use the latest version and we will expose the default port of MongoDB, which is 27017.

FROM mongo:latest

EXPOSE 27017

Docker-compose

In the MongoDB docker-compose, we will provide two environment variables. The first is MONGO_INITDB_ROOT_USERNAME, to define the root user, and the second is MONGO_INITDB_ROOT_PASSWORD, where we will add the password for this user.

    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: 12345678

We will also use mongo-express, which is a web interface to facilitate the manipulation of Mongo, similar to PgAdmin for PostgreSQL.

mongo-express:
    image: mongo-express

To function correctly, we need to inform in the mongo-express variables the user and password that we created for MongoDB, in addition to the database URL.

    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: admin
      ME_CONFIG_MONGODB_ADMINPASSWORD: 12345678
      ME_CONFIG_MONGODB_URL: mongodb://admin:12345678@database:27017/

The structure of the URL is as follows: <Driver>://<user>:<password>@<host>:<port>/. As we are using the URL externally, we will use the name of our MongoDB service, which is database. If you are going to make the connection inside the Mongo container using mongosh, you will have to replace the host with localhost.

To be able to access mongo-express, it will be necessary to create a username and password. This will be done through the ME_CONFIG_BASICAUTH_USERNAME and ME_CONFIG_BASICAUTH_PASSWORD variables.

      ME_CONFIG_BASICAUTH_USERNAME: mongo
      ME_CONFIG_BASICAUTH_PASSWORD: 123456

It is necessary for the services to use the same network to facilitate communication between them.

version: '3.8'

services:
  database:
    container_name: mongo_db
    build:
      context: .
      dockerfile: Dockerfile.mongo
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: 12345678
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
    networks:
      - mynet4

  mongo-express:
    image: mongo-express 
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: admin
      ME_CONFIG_MONGODB_ADMINPASSWORD: 12345678
      ME_CONFIG_MONGODB_URL: mongodb://admin:12345678@database:27017/
      ME_CONFIG_BASICAUTH_USERNAME: mongo
      ME_CONFIG_BASICAUTH_PASSWORD: 123456
    depends_on:
      - database
    ports:
      - "8081:8081"
    networks:
      - mynet4

volumes:
  mongo_data:

networks:
  mynet4:
    driver: bridge

Microsoft SQL Server

The SQL Server, unlike other databases, has its image maintained by the Microsoft Container Registry, instead of the Docker Hub.

Dockerfile

The image used is the Linux version of SQL Server. For more information or to use a specific database image, access here.

FROM mcr.microsoft.com/mssql/server:2022-latest

EXPOSE 1433

Docker-compose

Unlike other banks, it is necessary to use the ACCEPT_EULA variable to confirm that you accept the terms of the End User License Agreement. And in the MSSQL_SA_PASSWORD variable, it is necessary to follow Microsoft's password policy (see here).

version: '3.8'

services:
  database:
    container_name: sqlserver_db
    build: 
      context: .
      dockerfile: Dockerfile.sqlserver
    environment:
      ACCEPT_EULA: Y
      MSSQL_SA_PASSWORD: Admin123#
    ports:
      - "1455:1433"
    networks:
      - mynet5

networks:
  mynet5:
    driver: bridge

For more information about the image, instructions, and how to use SQL Server commands, access the official Microsoft documentation here.

Redis

Redis, like MongoDB, is also a NoSQL database. It is an in-memory database that uses a key-value data structure and is widely used for cache.

Docker-compose

The Redis Compose will be simpler. We will use the image tag to indicate which image our container will pull, and we will also expose the default Redis port, which is 6379.

    image: redis
    ports:
      - "6379:6379"

In Redis, we can also customize its configuration through a file called redis.conf, where we can define, for example, which addresses it can connect to, how much memory will be used, specify the protocol that can be used, and many other settings. See more about Redis configurations here.

version: '3.8'

services:
  database:
    image: redis
    container_name: redis_db
    ports:
      - "6379:6379"
    networks:
      - mynet6

networks:
  mynet6:
    driver: bridge

MariaDB

We will use version 11.2.3 of MariaDB and, like MySQL, we will expose port 3306.

FROM mariadb:11.2.3

EXPOSE 3306

Docker-compose

The MariaDB docker-compose will be similar to MySQL's, with the only difference in the environment being that we will only swap the MYSQL prefix for MARIADB.

    environment:
      MARIADB_ROOT_PASSWORD: 13246578
      MARIADB_DATABASE: mydb
      MARIADB_USER: admin
      MARIADB_PASSWORD: admin123

We will also have an example of docker-compose using DBeaver here.

version: '3.8'

services:
  database:
    build:
      context: .
      dockerfile: Dockerfile.mariadb
    environment:
      MARIADB_ROOT_PASSWORD: 13246578
      MARIADB_DATABASE: mydb
      MARIADB_USER: admin
      MARIADB_PASSWORD: admin123
    ports:
      - "3306:3306"
    volumes:
      - mariadb_data:/var/lib/mysql
    networks:
      - mynet7

volumes:
  mariadb_data:

networks:
  mynet7:
    driver: bridge

Elasticsearch

Elasticsearch is another NoSQL database on our list. It is widely used as a search engine, for log analysis, business analysis, and other purposes.

For a better experience, I will create a container using Elasticsearch and Kibana, which is a data visualization plugin used with Elastic. Both are part of the Elastic Stack (or ELK Stack), which includes other tools such as Beats and Logstash.

Dockerfile

In our Dockerfile, we will use version 8.12.1 of Elasticsearch. We will also create a directory where we will copy a script to execute two necessary commands to use Elastic with Kibana. Finally, we will expose the default Elasticsearch port, which is 9200.

FROM docker.elastic.co/elasticsearch/elasticsearch:8.12.1

WORKDIR /elastic

COPY setup_elasticsearch.sh /elastic

EXPOSE 9200

In this script, we will execute two necessary commands. The first is to get the password for the elastic user, and the second command will be to generate the Kibana token. Basically, both commands are being executed and responding that we want to reset the password and generate the token.

#!/bin/bash

echo "y" | /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic

echo "y" | /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana

The use of the script is optional; you can execute the commands manually through the container terminal. But if you want to use it, just enter the container terminal and execute it by writing ./setup_elasticsearch.sh.

Docker-compose

The Compose will have some different environment variables so far. We will use only two for this example, but it is worth remembering that there are several others in the Elasticsearch and Kibana documentation.

We are using the discovery.type variable as 'single-node'. By default, Elasticsearch allows the cluster to be 'multi-node', which allows connecting and joining several nodes in the same cluster.

And the second environment variable we will use is ES_JAVA_OPTS, which defines the initial size of the heap memory that Elasticsearch can use. In this case, we are defining the size as 1GB.

version: '3.8'

services:
  elasticsearch:
    build:
      context: .
      dockerfile: Dockerfile.elastic
    container_name: Elasticsearch
    environment:
      discovery.type: "single-node"
      ES_JAVA_OPTS: "-Xms1g -Xmx1g"
    ports:
      - "9200:9200"
    networks:
      - mynet8

  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.1
    container_name: kibana
    ports:
      - "5601:5601"
    networks:
      - mynet8

networks:
  mynet8:
    driver: bridge

Oracle

We are back to SQL databases, and for this example, I will use the 23c Free version of the Oracle database. Finding the Oracle image can be a bit more complicated, as like Microsoft with SQL Server, Oracle also maintains its own images, which makes it a bit harder to find and use in Docker. The version I will use can be found here.

Docker-compose

Our Compose will be simple, it will only be necessary to inform the password of our user in the environment variables.

     environment:
      ORACLE_PWD: 12345678

You can also modify the database character set using the ORACLE_CHARACTERSET variable, but it is optional. The default value is set to AL32UTF8.

version: '3.8'

services:
  database:
    image: container-registry.oracle.com/database/free:latest
    container_name: oracle
    environment:
      ORACLE_PWD: 12345678
    ports:
      - "1521:1521"
    volumes:
      - "oracle_data:/opt/oracle/oradata"
    networks:
      - mynet9

volumes:
  oracle_data:

networks:
  mynet9:
    driver: bridge

To learn more about this database, here are some useful links. Get Started teaches you how to install Oracle in other ways and also shows you how to connect to SQL via the terminal and in various languages. Oracle Database 23c to learn more about this version. And also the Oracle Container Registry if you want to obtain images of other Oracle products or even use other versions of the database.

Conclusion

I hope this article helps someone who is just starting out and takes some of the hassle out of creating a Docker container, as creating a database container is something we use a lot in our day-to-day lives. I'll leave here the link to the repository with all the examples.

Docker para iniciantes: Criando Containers de Bancos de Dados

João Vitor — Sat, 17 Feb 2024 16:28:32 +0000

Nesse artigo, vou fornecer alguns exemplos de como criar containers de bancos de dados utilizando Docker.

O foco deste artigo é auxiliar iniciantes no uso do Docker em seus projetos, abordando dúvidas sobre a criação do docker-compose ou Dockerfile.

Como referência para os bancos de dados mais populares, utilizei o top 9 da pesquisa do Stack Overflow de 2023.

Sumário

PostgreSQL
MySQL
SQLite
MongoDB
Microsoft SQL Server
Redis
MariaDB
Elasticsearch
Oracle

PostgreSQL

No nosso Dockerfile, será bastante simples. Vamos utilizar a imagem do PostgreSQL na versão 16 e expor a porta 5432 para que seja acessível pelo nosso container.

FROM postgres:16

EXPOSE 5432

Vamos adicionar ao nosso services o container do banco de dados e atribuir um nome a ele, neste caso, postgres_db.

services:
  database:
    container_name: postgres_db

Na tag build, informaremos onde se encontra nosso Dockerfile que será usado para configurar o nosso container do Postgres.

    build:
      context: .
      dockerfile: Dockerfile.postgres

No context utilizamos o ponto para indicar que o Dockerfile se encontra no mesmo diretório que o docker-compose.

Como PostgreSQL utiliza o usuário padrão postgres, adicionaremos apenas uma senha para o nosso usuário na seção environment.

    environment:
      POSTGRES_PASSWORD: 12345678

Agora precisamos adicionar as portas de comunicação entre a máquina host e o container, isso irá fazer com que tenha uma ligação entre os dois permitindo com que seja possível acessar o banco de dados que foi criado no container.

    ports:
      - "5432:5432"

A criação de volumes é opcional, mas é algo interessante de se fazer quando estamos utilizando banco de dados, pois permite que ocorra a persistência de dados do nosso container e mesmo que ele seja destruído podemos recriar o container com os dados intactos a partir do volume.

    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
    postgres_data:

Por último iremos criar uma Network. Elas são usadas para facilitar a comunicação dos nossos services. Por exemplo, digamos que você deseja criar um Compose que tenha o Postgres e o pgAdmin, para facilitar a interação entre eles, adicionamos ambos na mesma network para ajudar na comunicação (Exemplo aqui).

    networks:
      - mynet

networks:
  mynet:
    driver: bridge

Docker-compose

version: '3.8'

services:
  database:
    container_name: postgres_db
    build:
      context: .
      dockerfile: Dockerfile.postgres
    environment:
      POSTGRES_PASSWORD: 12345678
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - mynet

volumes:
  postgres_data:

networks:
  mynet:
    driver: bridge

MySQL

Para o Dockerfile do MySQL, faremos a mesma configuração do PostgreSQL, com a diferença de que vamos expor a porta padrão do MySQL.

FROM mysql:8.3

EXPOSE 3306

O docker-compose seguirá a mesma estrutura do compose do Postgres, com a diferença de que na seção environment serão adicionados mais alguns campos além da senha do usuário.

    environment:
      MYSQL_ROOT_PASSWORD: 12345678
      MYSQL_DATABASE: mydb
      MYSQL_USER: admin
      MYSQL_PASSWORD: admin123

O campo MYSQL_ROOT_PASSWORD, como o nome sugere, será a senha do usuário root. Não confunda com o campo MYSQL_PASSWORD, que é a senha do usuário defininda no campo MYSQL_USER. O campo MYSQL_DATABASE é o nome do banco de dados que será criado ao construir o container. Você pode criar outros bancos de dados após a criação do container usando comandos do MySQL ou um cliente de banco de dados, como o DBeaver (Exemplo aqui).

Docker-compose

version: '3.8'

services:
  database:
    container_name: mysql_db
    build:
      context: .
      dockerfile: Dockerfile.mysql
    environment:
      MYSQL_ROOT_PASSWORD: 12345678
      MYSQL_DATABASE: mydb
      MYSQL_USER: admin
      MYSQL_PASSWORD: admin123
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - mynet2

volumes:
  mysql_data:

networks:
  mynet2:
    driver: bridge

SQLite

O SQLite é diferente dos outros bancos de dados mencionados aqui. Ele é um banco de dados disk-based, o que significa que armazena os dados gerados em um arquivo no próprio sistema e não depende de um servidor, como os outros bancos de dados apresentados. Geralmente, os arquivos são salvos com a extensão .db.

É amplamente utilizado em aplicações móveis, principalmente no Android, devido à sua presença em muitos dispositivos.

Dockerfile

Para o Dockerfile do SQLite, usaremos uma imagem de uma distribuição Linux chamada Alpine, conhecida por sua leveza, o que a torna uma ótima opção para containers Docker.

FROM alpine:3.19

RUN apk add --no-cache sqlite

WORKDIR /database

Neste Dockerfile, instalamos o SQLite em nosso container e criamos um diretório chamado "database", onde executaremos nossos comandos do SQLite e salvaremos os bancos de dados criados.

Docker-compose

O Compose do SQLite seguirá uma estrutura semelhante ao do Postgres e do MySQL, mas com algumas diferenças.

A primeira diferença está nos volumes, onde vamos explicitar o diretório em que o volume será montado, permitindo uma manipulação mais eficiente dos dados do container.

    volumes:
      - ./sqlite_data:/database

A segunda diferença é o comando tail -f /dev/null. Como o SQLite é um banco de dados disk-based e não possui um servidor para manter o container ativo, usamos este comando para manter o container em execução.

command: ["tail", "-f", "/dev/null"]

O comando tail é usado para exibir as últimas linhas de um arquivo, enquanto o argumento -f serve para especificar o arquivo que o comando deverá seguir esperando novas linhas. Ao especificarmos /dev/null, que não contêm nada, o comando não exibirá nenhum conteúdo no terminal, mantendo assim nosso container ativo para que possamos utilizar os comandos do SQLite no terminal.

version: '3.8'

services:
  database:
    container_name: sqlite_db
    build:
      context: .
      dockerfile: Dockerfile.sqlite
    volumes:
      - ./sqlite_data:/database
    networks:
      - mynet3
    command: ["tail", "-f", "/dev/null"]

volumes:
  sqlite_data:

networks:
  mynet3:
    driver: bridge

MongoDB

O MongoDB é um banco de dados NoSQL, diferentemente dos outros apresentados até agora, que eram SQL, ou seja, bancos relacionais. O Mongo é um banco de dados orientado a documentos e é amplamente utilizado por sua flexibilidade, escalabilidade e facilidade de manipulação.

Dockerfile

Nosso Dockerfile seguirá o mesmo padrão dos outros. Utilizaremos a versão latest e iremos expor a porta padrão do MongoDB, que é 27017.

FROM mongo:latest

EXPOSE 27017

Docker-compose

No docker-compose do MongoDB, forneceremos duas variáveis de ambiente. A priemira é MONGO_INITDB_ROOT_USERNAME, para definirmos o usuário root, e a segunda é MONGO_INITDB_ROOT_PASSWORD, onde adicionaremos a senha deste usuário.

    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: 12345678

Também utilizaremos o mongo-express, que é uma interface web para facilitar a manipulação do Mongo, semelhante ao PgAdmin do PostgreSQL.

mongo-express:
    image: mongo-express

Para funcionar corretamente, precisamos informar nas variáveis do mongo-express o usuário e senha que criamos para o MongoDB, além da URL do banco de dados.

    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: admin
      ME_CONFIG_MONGODB_ADMINPASSWORD: 12345678
      ME_CONFIG_MONGODB_URL: mongodb://admin:12345678@database:27017/

A estrutura da URL é da seguinte forma <Driver>://<user>:<password>@<host>:<port>/. Como estamos utilizando a URL externamente, usaremos o nome do nosso service do MongoDB, que é database, Caso vá fazer a conexão dentro do container do Mongo utilizando o mongosh, você terá que substituir o host para localhost.

Para poder acessar mongo-express, será necessário criar um usuário e senha. Isso será feito através das variáveis ME_CONFIG_BASICAUTH_USERNAME e ME_CONFIG_BASICAUTH_PASSWORD.

      ME_CONFIG_BASICAUTH_USERNAME: mongo
      ME_CONFIG_BASICAUTH_PASSWORD: 123456

É necessário que os services utilizem a mesma network para facilitar a comunicação entre eles.

version: '3.8'

services:
  database:
    container_name: mongo_db
    build:
      context: .
      dockerfile: Dockerfile.mongo
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: 12345678
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
    networks:
      - mynet4

  mongo-express:
    image: mongo-express 
    environment:
      ME_CONFIG_MONGODB_ADMINUSERNAME: admin
      ME_CONFIG_MONGODB_ADMINPASSWORD: 12345678
      ME_CONFIG_MONGODB_URL: mongodb://admin:12345678@database:27017/
      ME_CONFIG_BASICAUTH_USERNAME: mongo
      ME_CONFIG_BASICAUTH_PASSWORD: 123456
    depends_on:
      - database
    ports:
      - "8081:8081"
    networks:
      - mynet4

volumes:
  mongo_data:

networks:
  mynet4:
    driver: bridge

Microsoft SQL Server

O SQL Server, diferentemente dos outros bancos de dados, tem sua imagem é mantida pelo Registro de Contêiner da Microsoft, em vez do Docker Hub.

Dockerfile

A imagem utilizada é a versão Linux do SQL Server. Para mais informações ou para utilizar uma imagem específica do banco de dados, acesse aqui.

FROM mcr.microsoft.com/mssql/server:2022-latest

EXPOSE 1433

Docker-compose

Diferente dos outros bancos, é necessário utilizar a variável ACCEPT_EULA para confirmar que aceita os temos do Contrato de Licença do Usuário Final. E na variável MSSQL_SA_PASSWORD, é necessário seguir a política de senha da Microsoft (veja aqui).

version: '3.8'

services:
  database:
    container_name: sqlserver_db
    build: 
      context: .
      dockerfile: Dockerfile.sqlserver
    environment:
      ACCEPT_EULA: Y
      MSSQL_SA_PASSWORD: Admin123#
    ports:
      - "1455:1433"
    networks:
      - mynet5

networks:
  mynet5:
    driver: bridge

Para mais informações sobre a imagem, instruções e como utilizar os comando do SQL Server, acesse a documentação oficial da Microsoft aqui.

Redis

O Redis, assim como o MongoBD, também é um banco de dados NoSQL. É um banco de dados em memória que utiliza uma estrutura de dados chave-valor e é amplamente utilizado para cache.

Docker-compose

O Compose do Redis será mais simples. Utilizaremos a tag image para indicar qual será a imagem que nosso container irá fazer o pull e também exporemos a porta padrão do Redis, que é a 6379.

    image: redis
    ports:
      - "6379:6379"

No Redis, também podemos personalizar sua configuração através de um arquivo chamado redis.conf, onde podemos definir, por exemplo, quais endereços ele poderá se conectar, quanto de memória será utilizado, especificar o protocolo que pode ser usado e muitas outras configurações. Veja mais sobre as configurações do Redis aqui.

version: '3.8'

services:
  database:
    image: redis
    container_name: redis_db
    ports:
      - "6379:6379"
    networks:
      - mynet6

networks:
  mynet6:
    driver: bridge

MariaDB

Iremos utilizar a versão 11.2.3 da MariaDB e, assim como o MySQL, iremos expor a porta 3306.

FROM mariadb:11.2.3

EXPOSE 3306

Docker-compose

O docker-compose da MariaDB será semelhante ao do MySQL, tendo como única diferença na envirenment que trocaremos somente o prefixo MYSQL por MARIADB.

    environment:
      MARIADB_ROOT_PASSWORD: 13246578
      MARIADB_DATABASE: mydb
      MARIADB_USER: admin
      MARIADB_PASSWORD: admin123

Também teremos um exemplo de docker-compose utilizando o DBeaver aqui.

version: '3.8'

services:
  database:
    build:
      context: .
      dockerfile: Dockerfile.mariadb
    environment:
      MARIADB_ROOT_PASSWORD: 13246578
      MARIADB_DATABASE: mydb
      MARIADB_USER: admin
      MARIADB_PASSWORD: admin123
    ports:
      - "3306:3306"
    volumes:
      - mariadb_data:/var/lib/mysql
    networks:
      - mynet7

volumes:
  mariadb_data:

networks:
  mynet7:
    driver: bridge

Elasticsearch

O Elasticsearch é mais um banco de dados NoSQL da nossa lista. Ele é muito usado como mecanismo de pesquisa, para análise de logs, análises de negócios e entre outros objetivos.

Para uma melhor experiência, irei criar um container utilizando o Elasticsearch e o Kibana, que é um plugin de visualização de dados utilizado com o Elastic. Ambos fazem parte da Elastic Stack (ou ELK Stack), que inclui outras ferramentas como o Beats e o Logstash.

Dockerfile

No nosso Dockerfile, iremos utilizar a versão 8.12.1 do Elasticsearch. Também criaremos um diretório onde vamos copiar um script para executar dois comandos necessários para utilizar o Elastic com o Kibana. Por fim, iremos expor a porta padrão do Elasticsearch, que é a 9200.

FROM docker.elastic.co/elasticsearch/elasticsearch:8.12.1

WORKDIR /elastic

COPY setup_elasticsearch.sh /elastic

EXPOSE 9200

Nesse script, iremos executar dois comandos que são necessários. O primeiro é para conseguirmos a senha do usuário elastic, e o segundo comando será para gerarmos o token do kibana. Basicamente, ambos os comandos estão sendo executados e respondendo que queremos resetar a senha e gerar o token.

#!/bin/bash

echo "y" | /usr/share/elasticsearch/bin/elasticsearch-reset-password -u elastic

echo "y" | /usr/share/elasticsearch/bin/elasticsearch-create-enrollment-token -s kibana

A utilização do script é opcional; você pode executar os comandos manualmente pelo terminal do container. Mas, caso deseje utilizar, basta entrar no terminal do container e executá-lo escrevendo ./setup_elasticsearch.sh.

Docker-compose

O Compose terá algumas variáveis de ambiente diferentes até agora. Vamos utilizar apenas duas para este exemplo, mas vale lembrar que na documentação do Elasticsearch e do Kibana existe várias outras.

Estamos utilizando a variável discovery.type como "single-node". Por padrão, o Elasticsearch permite que o cluster seja "multi-node", o que permite conectar e juntar vários nós no mesmo cluster.

E a segunda variável de ambiente que vamos utilizar é a ES_JAVA_OPTS, que define o tamanho inicial da memória heap que o Elasticsearch pode usar. Neste caso, estamos definindo o tamanho como 1GB.

version: '3.8'

services:
  elasticsearch:
    build:
      context: .
      dockerfile: Dockerfile.elastic
    container_name: Elasticsearch
    environment:
      discovery.type: "single-node"
      ES_JAVA_OPTS: "-Xms1g -Xmx1g"
    ports:
      - "9200:9200"
    networks:
      - mynet8

  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.1
    container_name: kibana
    ports:
      - "5601:5601"
    networks:
      - mynet8

networks:
  mynet8:
    driver: bridge

Oracle

Voltamos aos bancos de dados SQL, e para este exemplo, irei utilizar a versão 23c Free do banco de dados da Oracle. Encontrar a imagem da Oracle pode ser um pouco mais complicado, pois assim como a Microsoft com o SQL Server, a Oracle também mantêm suas próprias imagens, o que torna um pouco mais difícil de achar e utilizar no Docker. A versão que irei utilizar pode ser encontrada aqui.

Docker-compose

Nosso Compose será simples, sendo necessário informar apenas a senha do nosso usuário nas variáveis de ambiente.

     environment:
      ORACLE_PWD: 12345678

Você também pode modificar o conjunto de caracteres do banco de dados utilizando a variável ORACLE_CHARACTERSET, mas é opcional. O valor padrão é definido como AL32UTF8.

version: '3.8'

services:
  database:
    image: container-registry.oracle.com/database/free:latest
    container_name: oracle
    environment:
      ORACLE_PWD: 12345678
    ports:
      - "1521:1521"
    volumes:
      - "oracle_data:/opt/oracle/oradata"
    networks:
      - mynet9

volumes:
  oracle_data:

networks:
  mynet9:
    driver: bridge

Para conhecer melhor esse banco de dados, gostaria de deixar alguns links úteis. O Get Started ensina a instalar o Oracle de outras formas e também ensina como se conectar no SQL pelo terminal e também em várias linguagens. O Oracle Database 23c para se aprofundar mais nessa versão. E também o Oracle Container Registry caso queira obter as imagens de outros produtos da Oracle ou até mesmo utilizar outras versões do banco de dados.

Conclusão

Espero que este artigo ajude alguém que está começando e tire algumas dificuldades ao criar seu container Docker, pois criar container de banco de dados é algo que utilizamos muito no nosso dia a dia. Vou deixar aqui o link do repositório com todos os exemplos.