O Docker está se tornando cada vez mais popular e eu o tenho introduzido lentamente em meus projetos. Ele facilita a distribuição dos seus aplicativos porque, independentemente de onde você implantar os contêineres, a experiência será a mesma. Vamos ver como isso funciona usando o Docker e o Node.js, que tem muitas variações. Embora eles geralmente funcionem independentemente do cenário de aplicativos Web, não é possível ter certeza ao usar o tempo de execução do Node.js.
Veremos como criar um NoSQL e implantá-lo junto com um contêiner de aplicativo da Web personalizado que usa o Node e o Docker para encapsular o Couchbase funções.
O que é o Node.js?
Antes de começarmos o tutorial, vamos dedicar um minuto para definir Node.js. Em vez de ser executado em um navegador, o Node é um tempo de execução de código aberto e totalmente multiplataforma para executar JavaScript em um ambiente de servidor. Com o Node.js, os desenvolvedores podem criar aplicativos totalmente em nuvem que operam de forma invisível para os usuários, mas que fornecem funcionalidade crucial para as empresas modernas. O Couchbase é otimizado para executar aplicativos criados com o Node.js. Este tutorial demonstra como aproveitar esse recurso emparelhando o Node.js e os contêineres do Docker.
Se esta é a primeira vez que você está sendo exposto a Docker vamos detalhar o que esperamos alcançar. O Couchbase publicou uma imagem oficial do Docker para Docker Hub para os desenvolvedores do Node.js, mas a imagem não é pré-provisionada. Isso não é ruim e é definitivamente o que esperamos de um contêiner de banco de dados. Isso significa que precisamos criar uma imagem personalizada com base na imagem oficial, caso contrário, quando implantarmos o Couchbase, ele não terá sido configurado. Vamos usar escrever um aplicativo em Node.js e "Dockerizá-lo" em um pacote de contêiner. Esses dois contêineres do Docker do Couchbase e do Node.js poderão se comunicar entre si.
Criação de uma imagem e um contêiner do Docker do Couchbase Server personalizado
Crie um diretório em algum lugar do seu computador e inclua os dois arquivos a seguir:
|
1 2 |
Dockerfile configure.sh |
O arquivo de dockerfile de exemplo - Dockerfile - representará nossa imagem personalizada, e o configure.sh será um script de tempo de execução para quando implantarmos o nosso contêiner.
Abra o Dockerfile e inclua o seguinte:
|
1 2 3 4 5 |
DE couchbase COPIAR configure.sh /opt/couchbase CMD ["/opt/couchbase/configure.sh"] |
Nossa imagem personalizada usará a imagem oficial do Couchbase como base. No momento da compilação, o script de configuração será copiado para a imagem. Quando for executado, o script será executado. Vamos dar uma olhada nesse script.
Abra o configure.sh e inclua o seguinte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
set -m /entrypoint.sh couchbase-server & dormir 15 curl -v -X POST http://127.0.0.1:8091/pools/default -d memoryQuota=512 -d indexMemoryQuota=512 curl -v http://127.0.0.1:8091/node/controller/setupServices -d services=kv%2cn1ql%2Cindex curl -v http://127.0.0.1:8091/settings/web -d port=8091 -d username=$COUCHBASE_ADMINISTRATOR_USERNAME -d password=$COUCHBASE_ADMINISTRATOR_PASSWORD curl -i -u $COUCHBASE_ADMINISTRATOR_USERNAME:$COUCHBASE_ADMINISTRATOR_PASSWORD -X POST http://127.0.0.1:8091/settings/indexes -d 'storageMode=memory_optimized' curl -v -u $COUCHBASE_ADMINISTRATOR_USERNAME:$COUCHBASE_ADMINISTRATOR_PASSWORD -X POST http://127.0.0.1:8091/pools/default/buckets -d name=$COUCHBASE_BUCKET -d bucketType=couchbase -d ramQuotaMB=128 -d authType=sasl -d saslPassword=$COUCHBASE_BUCKET_PASSWORD dormir 15 curl -v http://127.0.0.1:8093/query/service -d "statement=CREATE PRIMARY INDEX ON `$COUCHBASE_BUCKET`" fg 1 |
Novamente, o objetivo do configure.sh é provisionar o servidor depois que ele for iniciado. Para fazer isso, podemos usar a API RESTful do Couchbase. A configuração inclui a criação de um cluster, a ativação dos serviços do Couchbase, a definição de credenciais de administração, a criação de um bucket e a criação de um índice N1QL no bucket.
No script de configuração, você notará que várias variáveis de ambiente estão sendo usadas, por exemplo, a variável $COUCHBASE_ADMINISTRATOR_USERNAME variável. Isso nos poupará de codificar informações potencialmente confidenciais na imagem. Em vez disso, podemos definir essas variáveis na implantação.
Agora vamos criar a imagem personalizada do Couchbase para o nosso projeto. No Docker Shell, execute o seguinte:
|
1 |
docker build -t couchbase-custom /path/to/directory/with/dockerfile |
No comando acima, o couchbase-custom text é o nome da nossa imagem, enquanto o path é o caminho para a nossa Dockerfile e configure.sh arquivos.
Com a imagem personalizada criada para o Couchbase, execute o seguinte comando para executá-la:
|
1 2 3 4 5 6 7 8 9 |
execução do docker -d \ -p 8091-8093:8091-8093 \ -e COUCHBASE_ADMINISTRATOR_USERNAME=Administrador \ -e COUCHBASE_ADMINISTRATOR_PASSWORD=senha \ -e COUCHBASE_BUCKET=default \ -e COUCHBASE_BUCKET_PASSWORD= \ --network="docker_default" \ --name couchbase \ couchbase-custom |
O comando acima diz que queremos implantar um contêiner, mapeando cada uma das portas necessárias do Couchbase. Passamos as variáveis de ambiente que são encontradas em nosso configure.sh e definimos em qual rede queremos que o contêiner seja executado. O contêiner terá o nome de couchbaseque também será o nome do host do contêiner.
Criação de um aplicativo da Web de API RESTful do Node.js
Com o Couchbase instalado e em execução, podemos desenvolver um aplicativo Node.js simples. Crie um diretório em algum lugar do seu computador para representar nosso projeto. Dentro desse projeto, crie um arquivo app.js arquivo. Vamos instalar pacotes privados com o NPM em um contêiner do Docker. No prompt de comando ou no terminal, execute o seguinte:
|
1 |
npm init --y |
O comando acima criará um arquivo package.json que será a base do nosso aplicativo Node.js. Há algumas dependências que precisam ser instaladas, portanto, vamos executar o seguinte para obtê-las:
|
1 |
npm install express couchbase body-parser uuid --save |
Estaremos usando expresso para criar nossa API, couchbase como nosso SDK, analisador de corpo para trabalhar com corpos POST, e uuid para gerar valores de identificação exclusivos que representarão as chaves do documento.
Com a base do aplicativo pronta, podemos começar a desenvolver o aplicativo. Abra a seção app.js e inclua o seguinte código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
var Couchbase = require("couchbase"); var Express = require("express"); var BodyParser = require("body-parser"); var UUID = require("uuid"); var app = Express(); var N1qlQuery = Couchbase.N1qlQuery; var bucket = (new Couchbase.Cluster("couchbase://" + process.env.COUCHBASE_HOST)).openBucket(process.env.COUCHBASE_BUCKET, process.env.COUCHBASE_BUCKET_PASSWORD); app.use(BodyParser.json()); app.get("/", function(request, response) { response.send("Tente usar os pontos de extremidade `/get` ou `/save`!"); }); app.get("/get", function(request, response) { var query = N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "`"); bucket.query(query, function(error, result) { if(error) { return response.status(500).send(error); } response.send(result); }); }); app.post("/save", function(request, response) { bucket.insert(UUID.v4(), request.body, function(error, result) { if(error) { return response.status(500).send(error); } response.send(result); }); }); var server = app.listen(process.env.APPLICATION_PORT || 3000, function() { console.log("Listening on port " + server.address().port + "..."); }); |
Então, o que está acontecendo no código acima?
Primeiro, importamos todas as dependências baixadas e, em seguida, estabelecemos uma conexão com o Couchbase. Você perceberá que estamos usando process.env em todo o código. Isso nos permite ler as variáveis de ambiente. Usaremos uma abordagem semelhante à que vimos na imagem do Couchbase.
A API tem dois pontos de extremidade que realmente fazem alguma coisa. O /salvar inserirá o que estiver no corpo da solicitação e o ponto de extremidade /get consultará o que estiver salvo no Couchbase.
Containerização do aplicativo da Web Node.js
Com o aplicativo criado, precisamos colocá-lo em um contêiner para que possa ser implantado facilmente com o Docker. No mesmo diretório que seu package.json adicione os dois arquivos a seguir:
|
1 2 |
Dockerfile .dockerignore |
O plano é criar uma imagem personalizada com base na imagem oficial do Docker do Node.js. Dentro da imagem Dockerfile inclua o seguinte:
|
1 2 3 4 5 6 7 8 |
DE nó:6-alpina COPY . /srv/ WORKDIR /srv EXECUTAR /usr/local/bin/npm install CMD /usr/local/bin/node app.js |
Durante o tempo de criação da imagem, copiaremos nosso projeto para o sistema de arquivos da imagem e alteraremos o diretório de trabalho. Em seguida, instalaremos todas as dependências encontradas no diretório package.json arquivo. Quando o contêiner é implantado, o arquivo app.js será executado.
Você deve estar se perguntando por que estamos fazendo uma instalação quando criamos a imagem. Estamos fazendo isso porque não queremos copiar as dependências para a imagem, pois pode haver incompatibilidades de sistema operacional e arquitetura. Para excluir as módulos_nó de nossa imagem, inclua o seguinte no diretório .dockerignore file:
|
1 |
módulos_nó |
Tudo o que você quiser excluir da imagem pode ir para esse arquivo.
Para criar essa imagem, execute o seguinte no Docker Shell:
|
1 |
docker build -t nodejs-custom /path/to/directory/with/dockerfile |
O nome da imagem para nosso aplicativo Node.js será chamado nodejs-custom e será baseado no diretório que contém o arquivo Dockerfile arquivo. Mais informações sobre a criação de imagens personalizadas do Docker podem ser encontradas em um Artigo anterior que eu escrevi.
Com a imagem disponível, precisamos executá-la. No Docker Shell, execute o seguinte:
|
1 2 3 4 5 6 7 8 9 |
execução do docker -d \ -p 3000:3000 \ -e COUCHBASE_HOST=couchbase \ -e COUCHBASE_BUCKET=default \ -e COUCHBASE_BUCKET_PASSWORD= \ -e APPLICATION_PORT=3000 \ --network="docker_default" \ --name nodejs \ nodejs-custom |
O comando acima deve parecer familiar ao que vimos na implantação do Couchbase. Estamos definindo o mapeamento de portas do nosso aplicativo, passando as variáveis de ambiente que são usadas no app.js definindo a rede do contêiner e o nome da imagem.
Se você acessar o navegador da Web e navegar para qualquer um dos endpoints do aplicativo da Web, ele deverá funcionar bem.
Uso de um arquivo Compose para implantação de contêineres do Docker
Ter que lembrar de todas as variáveis de ambiente e de tudo no comando para implementar os contêineres pode ser doloroso. Criar um arquivo Compose pode tornar as coisas muito mais simples.
Depois de criar suas duas imagens personalizadas, crie um arquivo docker-compose.yml em algum lugar de seu computador. Esse arquivo deve conter o seguinte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
versão: '2' serviços: couchbase: imagem: couchbase-custom portos: - 8091:8091 - 8092:8092 - 8093:8093 ambiente: - COUCHBASE_ADMINISTRATOR_USERNAME=Administrador - COUCHBASE_ADMINISTRATOR_PASSWORD=senha - COUCHBASE_BUCKET=padrão - COUCHBASE_BUCKET_PASSWORD= nodejs: imagem: nodejs-custom portos: - 3000:3000 ambiente: - COUCHBASE_HOST=couchbase - COUCHBASE_BUCKET=padrão - COUCHBASE_BUCKET_PASSWORD= - APPLICATION_PORT=3000 reiniciar: sempre |
Ao usar o Compose, você não precisa se preocupar em definir a rede, pois tudo no arquivo estará na mesma rede. Para iniciar qualquer um dos contêineres, execute o seguinte:
|
1 |
docker-compose run -d --service-ports --name couchbase couchbase |
Com o Couchbase, você não pode rodar tudo junto porque o Couchbase não tem um método para informar quando está pronto. Por isso, o aplicativo Node.js pode tentar se conectar antes que o Couchbase esteja pronto para aceitar conexões.
|
1 |
docker-compose up -d |
O comando acima geralmente ativa todos os contêineres no arquivo Compose, mas não podemos usá-lo neste cenário.
Conclusão
Se estiver se perguntando como pode implantar seu aplicativo da Web Node.js com Couchbase, o Docker é uma solução fácil. Depois de criar imagens do Couchbase ou do Node.js, você pode confiar que ele funcionará da mesma forma em qualquer servidor ou computador que esteja executando o Docker Engine.
Para obter mais informações sobre como usar o SDK do Couchbase Node.js, consulte a seção Portal do desenvolvedor do Couchbase.
[...] há muito tempo, escrevi sobre a conteinerização de uma API RESTful do Node.js e do Couchbase Server para demonstrar como é fácil implementar aplicativos da Web de forma rápida e confiável. Naquele [...]
[...] Se você estiver interessado em implantar um aplicativo da Web Node.js em contêineres que usa contêineres do Couchbase, confira este artigo que escrevi anteriormente chamado Implantar um aplicativo da Web Node.js com Couchbase como contêineres do Docker. [...]
[...] as postagens a seguir de Nic Raboy são muito úteis para começar a usar o Docker e [...]