Rafael Ugolini é um desenvolvedor de software full stack atualmente baseado em Bruxelas, na Bélgica. Ele trabalha com desenvolvimento de software há mais de 10 anos e, ultimamente, tem se concentrado em projetar soluções para a web e desenvolvimento usando Python e JavaScript. Rafael Ugolini é desenvolvedor de software sênior da Famoco.
Introdução
O Docker é um projeto excelente que está ajudando os desenvolvedores de todo o mundo a executar aplicativos em contêineres. Isso não só ajuda a enviar software mais rapidamente, mas também resulta na famosa frase "funciona na minha máquina". Neste artigo, explicarei como criar uma imagem modular do Couchbase que não requer nenhuma interação com a interface do usuário da Web para ter um banco de dados pronto para uso para você.
Todo o código está disponível online aqui.
Dockerfile
A primeira etapa é criar o Dockerfile.
Versão do Couchbase
|
1 |
FROM couchbase/server:enterprise-4.6.1 |
Este exemplo é baseado no Couchbase Server Enterprise 4.6.1, mas você pode mudar para a versão específica que está executando em seu ambiente.
Configuração da memória
|
1 2 3 |
ENV MEMORY_QUOTA 256 ENV INDEX_MEMORY_QUOTA 256 ENV FTS_MEMORY_QUOTA 256 |
Todos os valores aqui estão em MB:
- MEMORY_QUOTA: cota de RAM do serviço de dados por nó
- INDEX_MEMORY_QUOTA: cota de memória ram do serviço de índice por nó
- FTS_MEMORY_QUOTA: cota de memória ram do serviço de índice por nó
Serviços
|
1 |
ENV SERVICES "kv,n1ql,index,fts" |
Esses são os serviços que estarão disponíveis para o nó criado:
- kv: Dados
- n1ql: Consulta
- índice: Índice
- fts: Pesquisa de texto completo
Credenciais
|
1 2 |
ENV USERNAME "Administrator" ENV PASSWORD "password" |
Nome de usuário e senha a serem usados no Couchbase Server.
Opções de cluster
|
1 2 |
ENV CLUSTER_HOST "" ENV CLUSTER_REBALANCE "" |
Essas opções são usadas somente se você quiser adicionar mais de um nó no cluster.
- CLUSTER_HOST: nome do host do cluster ao qual esse nó deve se juntar
- CLUSTER_REBALANCE: defina "true" se quiser que o cluster seja reequilibrado depois que o nó for associado
Ponto de entrada
|
1 2 3 |
COPY entrypoint.sh /config-entrypoint.sh ENTRYPOINT ["/config-entrypoint.sh"] |
A imagem do Couchbase Server já vem com um script entrypoint.sh e não queremos substituí-lo. O truque aqui é copiar a nossa versão do entrypoint.sh para /config-entrypoint.sh, executar o entrypoint.sh do Couchbase Server em segundo plano e, depois de configurar o nó, anexar o script de volta ao original PONTO DE ENTRADA.
Ponto de entrada
O PONTO DE ENTRADA é usado em combinação com o script original da imagem do Couchbase Server. Vamos examinar linha por linha para entender como ele funciona.
Inicializar o servidor Couchbase
|
1 2 3 4 |
# Monitor mode (used to attach into couchbase entrypoint) set -m # Send it to background /entrypoint.sh couchbase-server & |
Primeiro, usamos set -m para ativar o controle de trabalho, o processo em execução em segundo plano (como o PONTO DE ENTRADA) são executados em um grupo de processos separado. Essa opção é desativada por padrão no modo não interativo, como scripts.
Funções utilitárias
|
1 2 3 4 5 |
# Check if couchbase server is up check_db() { curl --silent https://127.0.0.1:8091/pools > /dev/null echo $? } |
Essa função é usada para verificar quando o Couchbase Server começa a responder às chamadas HTTP.
|
1 2 3 4 5 6 7 |
# Variable used in echo i=1 # Echo with numbered_echo() { echo "[$i] $@" i=`expr $i + 1` } |
Essa é apenas uma função utilitária, adicione um número antes de qualquer eco no script para contar as etapas realizadas automaticamente.
|
1 2 3 4 5 6 7 8 |
# Parse JSON and get nodes from the cluster read_nodes() { cmd="import sys,json;" cmd="${cmd} print(','.join([node['otpNode']" cmd="${cmd} for node in json.load(sys.stdin)['nodes']" cmd="${cmd} ]))" python -c "${cmd}" } |
Para analisar a saída dos nós na API do Couchbase Server, estou usando uma função que executa o ython para ler STDINtransformá-lo em JSON e nos nós do Couchbase. Isso é usado para rebalanceamento.
Configurar o nó
|
1 2 3 4 5 6 7 8 |
# Wait until it's ready until [[ $(check_db) = 0 ]]; do >&2 numbered_echo "Waiting for Couchbase Server to be available" sleep 1 done echo "# Couchbase Server Online" echo "# Starting setup process" |
A primeira etapa é aguardar até que o servidor esteja pronto e, em seguida, usar a função numbered_echo você pode ver quanto tempo levou para o Couchbase Server ter as chamadas de API disponíveis.
|
1 2 3 4 |
HOSTNAME=`hostname -f` # Reset steps i=1 |
Em seguida, definimos uma variável HOSTNAME para ser usado em todas as chamadas de API que fazemos e também redefinimos o contador de numbered_echo definindo-o como 1.
|
1 2 3 4 5 6 7 8 |
numbered_echo "Initialize the node" curl --silent "https://${HOSTNAME}:8091/nodes/self/controller/settings" \ -d path="/opt/couchbase/var/lib/couchbase/data" \ -d index_path="/opt/couchbase/var/lib/couchbase/data" numbered_echo "Setting hostname" curl --silent "https://${HOSTNAME}:8091/node/controller/rename" \ -d hostname=${HOSTNAME} |
A primeira coisa a fazer é definir a configuração do armazenamento em disco e, em seguida, definir o nome do host.
Ingressar em um cluster
|
1 2 3 4 5 6 7 8 |
if [[ ${CLUSTER_HOST} ]];then numbered_echo "Joining cluster ${CLUSTER_HOST}" curl --silent -u ${USERNAME}:${PASSWORD} \ "https://${CLUSTER_HOST}:8091/controller/addNode" \ -d hostname="${HOSTNAME}" \ -d user="${USERNAME}" \ -d password="${PASSWORD}" \ -d services="${SERVICES}" > /dev/null |
Se CLUSTER_HOST estiver definido, o script tentará adicionar o contêiner para o cluster.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
if [[ ${CLUSTER_REBALANCE} ]]; then # "Unexpected server error without the sleep 2 sleep 2 numbered_echo "Retrieving nodes" known_nodes=$( curl --silent -u ${USERNAME}:${PASSWORD} https://${CLUSTER_HOST}:8091/pools/default | read_nodes ) numbered_echo "Rebalancing cluster" curl -u ${USERNAME}:${PASSWORD} \ "https://${CLUSTER_HOST}:8091/controller/rebalance" \ -d knownNodes="${known_nodes}" fi else |
Depois de adicionar o nó ao cluster, o script também pode verificar a variável REBALANCEAMENTO DE CLUSTER para ver se ele precisa reequilibrar o cluster automaticamente. É aqui que usamos a função Python para ler os nós de /pools/default ponto final.
Não ingressar em um cluster
|
1 2 3 4 5 |
numbered_echo "Setting up memory" curl --silent "https://${HOSTNAME}:8091/pools/default" \ -d memoryQuota=${MEMORY_QUOTA} \ -d indexMemoryQuota=${INDEX_MEMORY_QUOTA} \ -d ftsMemoryQuota=${FTS_MEMORY_QUOTA} |
Configurações de memória para os serviços.
|
1 2 3 |
numbered_echo "Setting up services" curl --silent "https://${HOSTNAME}:8091/node/controller/setupServices" \ -d services="${SERVICES}" |
Serviços a serem usados pelo nó.
|
1 2 3 4 5 6 7 |
numbered_echo "Setting up user credentials" curl --silent "https://${HOSTNAME}:8091/settings/web" \ -d port=8091 \ -d username=${USERNAME} \ -d password=${PASSWORD} > /dev/null fi |
Configure as credenciais para o nó.
Finalizar
|
1 2 3 |
# Attach to couchbase entrypoint numbered_echo "Attaching to couchbase-server entrypoint" fg 1 |
Para finalizar o script, nós o anexamos ao script original PONTO DE ENTRADA.
Exemplo
Para demonstrar como usá-lo, usarei a imagem registrada em Docker Hub com o código aqui.
Nó único
|
1 2 3 4 5 6 7 |
docker run -ti --name couchbase-server-nosetup \ -h node1.cluster \ -p 8091-8093:8091-8093 \ -p 11210:11210 \ -p 4369:4369 \ -p 21100-21299:21100-21299 \ rugolini/couchbase-server-nosetup |
Isso executa um único nó usando a memória mínima necessária e as credenciais padrão (Administrador/senha) registrados na imagem. Todas as portas de rede Servidor Couchbase Os usos também são expostos.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
docker run -ti --name couchbase-server-nosetup \ -h node1.cluster \ -p 8091-8093:8091-8093 \ -p 11210:11210 \ -p 4369:4369 \ -e MEMORY_QUOTA=512 \ -e INDEX_MEMORY_QUOTA=512 \ -e FTS_MEMORY_QUOTA=512 \ -e USERNAME=admin \ -e PASSWORD=adminadmin \ -p 21100-21299:21100-21299 \ rugolini/couchbase-server-nosetup |
O comando acima brinca um pouco com as variáveis de ambiente disponíveis no Dockerfile.
Aglomerado
Neste exemplo, conectaremos 3 nós no cluster.
|
1 |
docker network create couchbase |
Primeiro, precisamos criar uma rede do Couchbase na qual conectaremos todos os nós.
|
1 2 3 4 5 6 7 8 |
docker run -ti --name node1.cluster \ -p 8091-8093:8091-8093 \ -p 11210:11210 \ -p 4369:4369 \ -p 21100-21299:21100-21299 \ -h node1.cluster \ --network=couchbase \ rugolini/couchbase-server-nosetup |
Em seguida, criamos o primeiro nó.
|
1 2 3 4 5 6 |
docker run -ti --name node2.cluster \ --network=couchbase \ -h node2.cluster \ -e CLUSTER_HOST=node1.cluster \ -e CLUSTER_REBALANCE=true \ rugolini/couchbase-server-nosetup |
Como todas as portas de rede estão expostas no primeiro nó, não é necessário expô-las aqui.
Atenção aos detalhes que CLUSTER_HOST é definido como node1.cluster que é o nome do host do primeiro nó e REBALANCEAMENTO DE CLUSTER também é definido como verdadeiro. Quando o nó for adicionado ao cluster, ele se reequilibrará automaticamente.
|
1 2 3 4 5 |
docker run -ti --name node3.cluster \ --network=couchbase \ -h node3.cluster \ -e CLUSTER_HOST=node1.cluster \ rugolini/couchbase-server-nosetup |
O nó3 também é adicionado ao cluster, mas como REBALANCEAMENTO DE CLUSTER não foi definido, será necessário um rebalanceamento manual do cluster para que ele se torne disponível.
Esta postagem faz parte do Programa de Redação da Comunidade Couchbase
