Comunicação com o Couchbase por meio de um Dockerfile Script e Docker

Tenho trabalhado em um projeto com minha equipe que envolve a criação de uma seleção de microsserviços. Esses microsserviços preenchem um
O Couchbase Server armazena dados em um intervalo de nossa escolha e opera por meio de um servidor AWS EC2. O problema é que todos os usuários do
minha equipe tem uma linguagem de programação preferida. Se fôssemos instalar todas as linguagens do lado do servidor nesse servidor, ele provavelmente se tornaria
caro. Em vez disso, decidimos usar contêineres do Docker para cada microsserviço. Como estamos executando-os apenas em um intervalo, podemos
remover o contêiner após cada execução, mantendo nosso servidor principal leve e livre de software.

Vamos examinar algumas das coisas que estamos fazendo para tornar essa solução possível.

Configuração do Docker em uma instância EC2

Vamos supor que o nosso host Amazon EC2 seja o Ubuntu 14.04, pois, até o momento, essa é a versão de suporte de longo prazo do Ubuntu. Faça login no
o host EC2 e execute o seguinte como um sudoer:

O procedimento acima instalará o Docker no host, e não como uma máquina virtual, como pode ocorrer em um ambiente Mac ou Windows.

Neste momento, o Docker pode ser usado. Nossa intenção é usar um script de compilação, mas você também pode usá-lo manualmente. Se você
Se você ainda não instalou o Couchbase na instância do EC2, pode fazer isso também. Faça o download do arquivo Debian mais recente do site
Downloads do Couchbase e execute o seguinte:

Como alternativa, você pode optar por ativar uma instância do Amazon EC2 que já esteja executando o Couchbase Server. Mais informações sobre isso
assunto pode ser encontrado aqui.

Projetando um script de compilação

O Dockerfile é o nosso script de compilação para criar imagens do Docker. Nele, definimos o sistema operacional a ser usado, o que
pacotes que serão baixados e quais arquivos conterão.

Sou mais do tipo Node.js, portanto meus microsserviços nesse projeto são Node.js. Alguns dos outros usaram Java e Python, embora este artigo
não é específico de nenhuma linguagem. O arquivo de compilação de um dos meus microsserviços é parecido com o seguinte:

Para decompor o arquivo acima, vamos dar uma olhada em todas as peças.

Primeiro, determinamos que essa imagem será do Ubuntu 14.04 e não interativa. Essa será uma imagem de base, portanto, antes de iniciarmos
Para executar projetos do Node.js, precisamos instalar as dependências. Atualizamos a lista de repositórios do sistema operacional e instalamos enrolar porque
O Ubuntu não vem com ele por padrão e precisaremos dele para instalar o repositório do Node.js. Uma vez enrolar está instalado
podemos adicionar o repositório do Node.js 4.x e instalar o software.

É aqui que as coisas se tornam um pouco mais específicas para o meu projeto. Meu projeto tem os seguintes arquivos e diretórios:

• modelos/
• rotas/
• package.json
• app.js
• config.json
• mock_data.xml

O Dockerfile que estamos criando está dentro da raiz dessa estrutura de projeto.

O que precisa acontecer é que precisamos copiar tudo em nossa imagem. Isso é feito usando o comando CÓPIA comandos. Uma vez
tudo foi copiado, podemos dizer ao Node Package Manager (NPM) para instalar todas as dependências encontradas no arquivo
package.json arquivo.

O CMD é o que será executado quando implementarmos nossa imagem construída.

Criação e execução de um contêiner

No momento, o Dockerfile deve estar no mesmo diretório que os arquivos de script ou aplicativo. Embora
sem importância, meus arquivos de aplicativo são um projeto Node.js que será executado automaticamente.

Antes de executar nosso contêiner, devemos primeiro criá-lo com base no blueprint do nosso Dockerfile. Execute o seguinte
por meio da interface de linha de comando do Docker:

O comando acima percorrerá cada etapa do script e marcará nossa imagem com o nome meu_projeto. Uma vez construído, a qualquer momento
você pode executar o seguinte na ferramenta de linha de comando do Docker para executar nossa imagem:

Mas espere um pouco. Por que estamos fazendo --add-host="localhost:10.0.2.2"? Neste exemplo específico, estamos supondo que
O Couchbase está sendo executado em nosso computador local com as informações localhost:8091. No aplicativo Node.js, vamos
Suponha que tentemos estabelecer uma conexão com o Couchbase Server via http://localhost:8091. Por padrão, o Docker será
em uma sub-rede diferente, o que torna isso impossível. Localhost não será o que você está pensando. É por isso que adicionamos um host com um
mapeamento.

Em determinados cenários, você também poderá fazer --net=host em vez de --add-host="localhost:10.0.2.2".
Mais informações podem ser encontradas em
o Documentação oficial do Docker.

Como copiamos todo o nosso projeto Node.js e adicionamos CMD ["node", "app.js"]Quando a imagem for iniciada, o comando será executado.
O app.js em teoria, conterá nossa lógica para fazer a interface com o Couchbase Server por meio do SDK do Couchbase Node.js. O mesmo
pode ser feito em qualquer linguagem de programação e no Couchbase SDK. Após a conclusão do comando, o contêiner será removido.

Conclusão

Você acabou de ver como fazer o Docker funcionar em um servidor Ubuntu e executar um projeto em um contêiner por meio de um script. Embora esse método de
não será para todo mundo, ele atende à nossa necessidade de poder executar um projeto em qualquer linguagem de programação e
fazer com que ele armazene dados no Couchbase Server em execução no nível do host.