Usando Elastic APM com servidor Docker para monitorar uma aplicação Node.js
Tags: docker, node, elasticsearch, monitoring
Published: 2023-02-25 21:24:37

## Introdução

O Elastic APM é uma ferramenta de monitoramento de desempenho de aplicativos que permite coletar e analisar dados de desempenho em tempo real. Neste artigo, vamos ver como configurar o Elastic APM como um servidor Docker para monitorar uma aplicação Node.js.

## Pré-requisitos

Antes de começarmos, você deve ter o seguinte instalado em sua máquina:

- Docker
- Docker Compose

## Passo 1: Crie uma aplicação Node.js

Para este artigo, vamos criar uma aplicação Node.js simples. Crie um novo diretório e crie um arquivo chamado `index.js`. Adicione o seguinte código ao arquivo:

```js
const http = require('http');

const server = http.createServer((req, res) => {
    if (req.url === '/health') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'UP' }));
    } else {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Hello, world!\n');
    }
});

const port = process.env.PORT || 3000;

server.listen(port, () => {
    console.log(Server running on port ${port});
});


```


Este código cria um servidor HTTP simples que responde com "Hello, world!" quando você acessa a raiz do servidor. Quando você acessa `/health`, o servidor retorna um JSON que indica que está saudável.

## Passo 2: Crie um arquivo `Dockerfile`

O próximo passo é criar um arquivo `Dockerfile` para empacotar a aplicação Node.js em um contêiner Docker. Crie um novo arquivo chamado `Dockerfile` no diretório raiz do seu projeto e adicione o seguinte conteúdo:

```docker
FROM node:14-alpine

WORKDIR /app

COPY package.json .
COPY package-lock.json .
RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]
```


Este arquivo define uma imagem Docker que usa a imagem `node:14-alpine` como base. Ele define um diretório de trabalho na imagem, instala as dependências da aplicação, copia os arquivos da aplicação para o contêiner Docker e expõe a porta 3000. Por fim, ele define o comando `npm start` como o comando padrão que deve ser executado quando o contêiner é iniciado.

## Passo 3: Crie um arquivo `docker-compose.yml`

O próximo passo é criar um arquivo `docker-compose.yml` para orquestrar a execução dos contêineres da aplicação e do Elastic APM. Crie um novo arquivo chamado `docker-compose.yml` no diretório raiz do seu projeto e adicione o seguinte conteúdo:

```yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - '3000:3000'
    environment:
      - ELASTIC_APM_SERVICE_NAME=my-node-app
      - ELASTIC_APM_SERVER_URL=http://apm-server:8200
      - ELASTIC_APM_ENVIRONMENT=development
      - ELASTIC_APM_LOG_LEVEL=debug
    depends_on:
      - apm-server

  apm-server:
    image: docker.elastic.co/apm/apm-server:
    ports:
      - '8200:8200'
      - '1514:1514/udp'
    environment:
      - output.elasticsearch.hosts=[elasticsearch:9200]
      - apm-server.secret_token=${ELASTIC_APM_SECRET_TOKEN}
    volumes:
      - './apm-server/config/apm-server.yml:/usr/share/apm-server/apm-server.yml:ro'

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.16.2
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms256m -Xmx256m
      - http.host=0.0.0.0
      - transport.host=127.0.0.1
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    ports:
      - '9200:9200'
      - '9300:9300'
    volumes:
      - esdata:/usr/share/elasticsearch/data

volumes:
  esdata:
    driver: local
```


Este arquivo define três serviços:

- `app`: o serviço que executa a aplicação Node.js.
- `apm-server`: o serviço que executa o servidor Elastic APM.
- `elasticsearch`: o serviço que executa o Elasticsearch.

O serviço `app` é construído a partir da imagem definida no arquivo `Dockerfile` e expõe a porta 3000. Ele também define algumas variáveis de ambiente que são usadas pela biblioteca Elastic APM para se conectar ao servidor Elastic APM.

O serviço `apm-server` é construído a partir da imagem `docker.elastic.co/apm/apm-server`. Ele expõe as portas 8200 e 1514/udp, que são usadas para se comunicar com a biblioteca Elastic APM. Ele também define uma variável de ambiente que define a chave secreta usada pelo servidor Elastic APM para autenticação.

O serviço `elasticsearch` é construído a partir da imagem `docker.elastic.co/elasticsearch/elasticsearch`. Ele expõe as portas 9200 e 9300, que são usadas pelo Elasticsearch para se comunicar com a aplicação. Ele também define algumas variáveis de ambiente que são usadas para configurar o Elasticsearch.

## Passo 4: Inicie os contêineres

Agora que temos todos os arquivos necessários, podemos iniciar os contêineres. Para fazer isso, execute o seguinte comando no diretório raiz do seu projeto:

```txt
docker-compose up -d
```


Este comando inicia os três contêineres definidos no arquivo `docker-compose.yml`. Você deverá ver mensagens de log para cada contêiner à medida que eles são iniciados.

## Passo 5: Verifique se o Elastic APM está funcionando

Para verificar se o Elastic APM está funcionando, abra o Kibana em seu navegador em `http://localhost:5601`. No painel de navegação à esquerda, clique em "APM" para acessar a página de monitoramento de desempenho.

Se tudo estiver funcionando corretamente, você deverá ver sua aplicação Node.js listada na página "APM". Clique na aplicação para ver mais informações sobre o desempenho da aplicação.

Exemplo de aplicação no apm:


![Exemplo de aplicação no apm](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jidls4wzfi4gcse77mac.png)

## Conclusão
Neste artigo, vimos como usar o Elastic APM para monitorar uma aplicação Node.js em um ambiente Docker. O Elastic APM é uma ferramenta poderosa que fornece insights detalhados sobre o desempenho da sua aplicação, permitindo que você identifique problemas e otimize o desempenho.

Começamos criando um arquivo Dockerfile que define o ambiente de execução da nossa aplicação Node.js e adicionando a biblioteca Elastic APM à nossa aplicação. Em seguida, criamos um arquivo docker-compose.yml que define os contêineres para a aplicação Node.js, o servidor Elastic APM e o Elasticsearch.

Ao iniciar os contêineres, podemos verificar se o Elastic APM está funcionando acessando o Kibana e verificando se a nossa aplicação Node.js está listada na página "APM". A partir daí, podemos usar o Elastic APM para monitorar o desempenho da nossa aplicação e identificar possíveis gargalos ou problemas de desempenho.

Esperamos que este artigo tenha sido útil para você e que você agora tenha uma compreensão melhor de como usar o Elastic APM para monitorar uma aplicação Node.js em um ambiente Docker. Lembre-se de que o monitoramento do desempenho é uma parte importante do processo de desenvolvimento de software e pode ajudar a identificar problemas e melhorar a experiência do usuário.