Forem: Sysadminas

Conhecendo a ferramenta Opensearch

Thaynara Mendes — Mon, 06 Jun 2022 14:55:19 +0000

Heeey!

Podemos nos referir ao Opensearch como um fork do Elasticsearch e Kibana 7.10. Basicamente, o Opensearch é uma ferramente de monitoração de aplicação e análise de logs totalmente opensource (mas neste post vamos explorar um pouco mais sobre demais recursos que a ferramenta oferece).

Antes de tudo, vamos entender um pouco mais sobre o que a própria AWS nos conta sobre a ferramenta:

O que é Opensearch?

O OpenSearch é um conjunto distribuído de pesquisa e análise de código aberto usado para uma ampla variedade de casos de uso, como monitoramento de aplicações em tempo real, análise de logs e pesquisa de sites. O OpenSearch fornece um sistema altamente escalável para fornecer acesso rápido e resposta a grandes volumes de dados com uma ferramenta de visualização integrada, o OpenSearch Dashboards, que facilita a exploração de dados pelos usuários.
Assim como o Elasticsearch, o Opensearch oferece um mecanismo de pesquisa de texto completo distribuído baseado no Apache Lucene com uma interface de API RESTful e suporte para documentos JSON.

Qual a ideia por trás da criação?

Em 2021 a Elastic mudou a licença de software permissiva ALv2 para a Elastic License v2 (ELv2) and SSPL, essas licenças não seguem firmemente a ideia do Open Source e não oferecem as mesmas liberdades para os usuários. Logo, o opensearch virou um fork do Elasticsearch e Kibana na versão 7.10. Com o objetivo de oferecer uma ferramenta totalmente opensource para a comunidade.

Principais recursos do Opensearch que não fazem parte da licença free do Elasticsearch

Recurso	Benefício
Segurança avançada	Oferece recursos de criptografia, autenticação, autorização e auditoria. Eles incluem integrações com Active Directory, LDAP, SAML, Kerberos, tokens da Web JSON
Geração de relatórios	Agende, exporte e compartilhe relatórios de painéis, pesquisas salvas, alertas e visualizações.
Detecção de anomalias	Aproveite a detecção de anomalias de Machine Learning com base no algoritmo Random Cut Forest (RCF) para detectar anomalias automaticamente à medida que seus dados são ingeridos. Combine com Alertas para monitorar dados quase em tempo real e enviar notificações de alertas automaticamente.
Analisador de performance e framework RCA	Consulte várias métricas e agregações de performance do cluster. Use o PerfTop, a interface de linha de comando (CLI) para exibir e analisar essas métricas rapidamente. Use a framework de análise de causas-raiz (RCA) para investigar problemas de performance e confiabilidade em clusters.
Trace Analytics	Ingere e visualize dados OpenTelemetry para aplicações distribuídas. Visualize o fluxo de eventos entre essas aplicações para identificar problemas de performance.
Geração de alertas	Monitore dados automaticamente e envie notificações de alertas automaticamente para as partes interessadas. Crie condições de alerta altamente específicas usando a linguagem de consulta completa e os recursos de script do OpenSearch.

Vamos a prática!

Vamos subir o Opensearch e o Opensearch dashboards na versão de teste, esta versão, o Opensearch já provisiona todas as configurações de segurança (certificados).

Garanta que você tenha odocker-compose instalado.

Garanta que a variável vm.max_map_count esteja setada com o valor de 262144:

sysctl -w vm.max_map_count=262144

Essa configuração do sysctl não é permanente

Crie o arquivo docker-compose.yml:

version: '3'
services:
  opensearch-node1:
    image: opensearchproject/opensearch:latest
    container_name: opensearch-node1
    environment:
      - cluster.name=opensearch-cluster
      - node.name=opensearch-node1
      - discovery.seed_hosts=opensearch-node1,opensearch-node2
      - cluster.initial_master_nodes=opensearch-node1,opensearch-node2
      - bootstrap.memory_lock=true
      - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g" 
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536 
        hard: 65536
    volumes:
      - opensearch-data1:/usr/share/opensearch/data
    ports:
      - 9200:9200
      - 9600:9600
    networks:
      - opensearch-net
  opensearch-node2:
    image: opensearchproject/opensearch:latest
    container_name: opensearch-node2
    environment:
      - cluster.name=opensearch-cluster
      - node.name=opensearch-node2
      - discovery.seed_hosts=opensearch-node1,opensearch-node2
      - cluster.initial_master_nodes=opensearch-node1,opensearch-node2
      - bootstrap.memory_lock=true
      - "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g"
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    volumes:
      - opensearch-data2:/usr/share/opensearch/data
    networks:
      - opensearch-net
  opensearch-dashboards:
    image: opensearchproject/opensearch-dashboards:latest
    container_name: opensearch-dashboards
    ports:
      - 5601:5601
    expose:
      - "5601"
    environment:
      OPENSEARCH_HOSTS: '["https://opensearch-node1:9200","https://opensearch-node2:9200"]'
    networks:
      - opensearch-net

volumes:
  opensearch-data1:
  opensearch-data2:

networks:
  opensearch-net:

Assim que salvar o arquivo, suba todos os serviços:

docker-compose up -d

Temos que ter 3 containers rodando, dois opensearch e um opensearch Dashboards

CONTAINER ID   IMAGE                                            COMMAND                  CREATED         STATUS              PORTS                                                                                                      NAMES
7e1de85c3f8c   opensearchproject/opensearch-dashboards:latest   "./opensearch-dashbo…"   2 minutes ago   Up About a minute   0.0.0.0:5601->5601/tcp, :::5601->5601/tcp                                                                  opensearch-dashboards
40b047a9123e   opensearchproject/opensearch:latest              "./opensearch-docker…"   2 minutes ago   Up About a minute   9200/tcp, 9300/tcp, 9600/tcp, 9650/tcp                                                                     opensearch-node2
c72ebd7f6e3b   opensearchproject/opensearch:latest              "./opensearch-docker…"   2 minutes ago   Up About a minute   0.0.0.0:9200->9200/tcp, :::9200->9200/tcp, 9300/tcp, 0.0.0.0:9600->9600/tcp, :::9600->9600/tcp, 9650/tcp   opensearch-node1

Agora basta acessar o Opensearch Dashboard na porta 5601:

Você consegue acessar com user admin, senha admin.

Inserindo dados para visualização

Para visualizar dados eu importei alguns dados.

No Menu lateral, na área de Management, selecione o Dev Tools.

Através do Dev Tools, é possível realizar requisições direto no nós de Opensearch.

Os nossos documentos não tem nenhum campo do tipo datetime (ele é necessário para uma melhor visualização e análise), então primeiro vamos criar uma pipeline que irá criar o campo "indexed_at" em todo arquivo que for adicionado:

PUT /_ingest/pipeline/timestamp
{
  "description": "Adicionando o campo indexed_at nos documentos",
  "processors": [
    {
      "set": {
        "field": "indexed_at",
        "value": "{{_ingest.timestamp}}"
      }
    }
  ]
}

Vamos criar o índice e definir essa pipeline como default:

PUT /movies
{
  "settings": {
    "index.default_pipeline": "timestamp"
  }
}

Vamos adicionar um bulk request para alguns documentos:

PUT /movies/_bulk/
{ "index":{} }
{ "title" : " Predestination", "year":2014 , "genre":["Action", "Drama", "Sci-Fi"] }
{ "index":{} }
{ "title" : "Star Wars: Episode VII - The Force Awakens", "year":2015 , "genre":["Action", "Adventure", "Fantasy", "Sci-Fi"] }
{ "index":{} }
{ "title" : "Interstellar", "year":2014 , "genre":["Sci-Fi", "Adventure", "Drama"] }
{ "index":{} }
{ "title" : "Venom", "year":2018 , "genre":["Action", " Adventure", "Sci-Fi"] }
{ "index":{} }
{ "title" : "A Quiet Place Part II", "year":2020 , "genre":["Horror", "Sci-Fi", "Drama"] }
{ "index":{} }
{ "title" : "Donnie Darko", "year":2001 , "genre":["Drama", "Sci-Fi", "Mistery"] }
{ "index":{} }
{ "title" : "Black Widow", "year":2021 , "genre":["Action", " Adventure", "Sci-Fi"] }
{ "index":{} }
{ "title" : "Nobody", "year":2021 , "genre":["Action", "Drama", "Crime"] }
{ "index":{} }
{ "title" : "The Dark Knight", "year":2008 , "genre":["Action", "Drama", "Crime"] }
{ "index":{} }
{ "title" : "Inception", "year":2010 , "genre":["Action", " Adventure", "Sci-Fi"] }
{ "index":{} }
{ "title" : " The Matrix", "year":1999 , "genre":["Action",  "Sci-Fi"] }
{ "index":{} }
{ "title" : "Avatar", "year":2009 , "genre":["Action", " Adventure", "Fantasy"] }
{ "index":{} }
{ "title" : "Ex Machina", "year":2014 , "genre":["Action", " Adventure", "Sci-Fi"] }
{ "index":{} }
{ "title" : " The Hobbit: An Unexpected Journey", "year":2012 , "genre":[" Adventure", "Fantasy"] }
{ "index":{} }
{ "title" : "Wonder Woman", "year":2017 , "genre":["Action", " Adventure", "Fantasy"] }

Clique em um ícone de play para enviar a requisição:

Configurando Index Pattern

Ao retornar no Discover aparecerá uma página para criar o Index Pattern, clique em Create index pattern:

Index pattern name: movies*

Time field: indexed_at

Clique em Create Index pattern

Aparecerá todos os campos existentes neste index, podemos alterar o modo de visualização. Por exemplo:

Acesse o campo year e clique no ícone de editar:

Format: Number
Numeral.js format pattern: 0

Clique em Save field

Após retornar para o Discover, já conseguimos visualizar os documentos que adicionamos:

Um recurso que faz falta no Opensearch Dashboard é o Lens. Não foi possível inseri-lo porque esta feature do Kibana não é Open Source.

Espero que tenham gostado da ferramenta!
Até mais o/

Como coletar logs do PostgreSQL com o Filebeat

Beatriz Oliveira — Fri, 22 Jan 2021 12:42:36 +0000

O que é o PostgreSQL?

O PostgreSQL é um Sistema Gerenciador de Bancos de Dados (SGBD) open source.

Para conhecer mais sobre ele, recomendo a leitura do post Introdução ao PostgreSQL do DevMedia nesse link.

Aqui no nosso blog, a Renata Azevedo mostra como configurar um cluster de PostgreSQL e você pode ver esse tutorial nesse link.

Utilizando o Filebeat para coletar os logs do PostgreSQL

Ao utilizar o módulo PostgreSQL do Filebeat você consegue coletar e analisar os logs do PostgreSQL.

Para saber mais sobre esse módulo, acesse a documentação aqui nesse link

Instalação e configuração do Filebeat

Instale o Filebeat:

Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1
Linux: sudo rpm -vi filebeat-7.10.1-x86_64.rpm

Acesse o arquivo de configuração do Filebeat:

Windows: C:\Program Files\Filebeat\filebeat.yml
Linux: /etc/filebeat/filebeat.yml

Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable postgresql
Linux: sudo filebeat modules enable postgresql
Para modificar as configurações do módulo, altere o arquivo postgresql.yml:

Windows: modules.d/postgresql.yml
Linux: /etc/filebeat/modules.d/postgresql.yml

Por padrão, o arquivo vem com as seguintes informações e é aqui que você especifica o caminho para o seu diretório de logs:

# Module: postgresql
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.7/filebeat-module-postgresql.html
- module: postgresql
  # All logs
  log:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/diretório/do/log/postgresql/*.log*"]

Carregue o índice e os dashboards do módulo:

Windows: .\filebeat.exe setup
Linux: sudo filebeat setup

Inicie o serviço do Filebeat:

Windows: Start-Service filebeat
Linux: sudo service filebeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do seu PostgreSQL.

Como monitorar uma instância EC2 utilizando o infrastructure agent do New Relic

Beatriz Oliveira — Wed, 06 Jan 2021 18:51:21 +0000

Fazer a monitoração básica da sua infraestrutura é de extrema importância, visto que é através desse tipo de monitoração que vemos as principais métricas do ambiente, como consumo de CPU, memória. disco e intensidade do tráfego de rede por exemplo.

Nesse lab, vamos utilizar o infrastructure agent da New relic. Esse agente coleta os dados de infraestrutura dos seus hosts e manda eles diretamente para o New Relic.

Existem diversas formas de instalar ele no seu ambiente e nesse post eu vou mostrar como instalar ele de duas formas diferentes em uma EC2 Linux na Amazon.

Instalação do agent ao subir a instância

Você pode subir seus hosts já monitorados, no processo de criação do host faca a seguinte configuração.

Selecione a sua AMI, no exemplo estamos utilizando a AMI Linux 2.

Selecione o tipo de instância que você vai utilizar, no exemplo estamos usando uma t2.micro.

Configure os detalhes da instância
E aqui fica a parte mais importante do tutorial, insira nos detalhes avançados insira a seguinte configuração:

#!/bin/bash
echo "license_key: [00000000]" | sudo tee -a /etc/newrelic-infra.yml
sudo curl -o /etc/yum.repos.d/newrelic-infra.repo https://download.newrelic.com/infrastructure_agent/linux/yum/el/7/x86_64/newrelic-infra.repo
sudo yum -q makecache -y --disablerepo='*' --enablerepo='newrelic-infra'
sudo yum install newrelic-infra -y

No campo user data colocamos todos os comandos necessários para serem executados automaticamente para fazer a instalação do agent na máquina.

Configure o storage da sua máquina

Configure o security group

Revise as configurações e por fim, suba a instância.
Depois disso, acesse o Entity Explorer diretamente no New Relic e coloque o endereço do seu host.

Assim você já conseguirá ver as principais métricas de infra do seu host como mostra o exemplo abaixo.

Se você acessar o host, pode executar o comando systemctl status newrelic-infra para ver se o agent esta rodando como mostra a imagem abaixo:

Instalar o agent em um host que já está funcionando

Uma alternativa para você que já tem o host funcionando, mas ainda não tem o agente instalado é executar os comandos abaixo para fazer a instalação completa em poucos minutos.

# Create a configuration file and add your license key \
echo "license_key: 00000000" | sudo tee -a /etc/newrelic-infra.yml && \
\
# Create the agent's yum repository \
sudo curl -o /etc/yum.repos.d/newrelic-infra.repo https://download.newrelic.com/infrastructure_agent/linux/yum/el/7/x86_64/newrelic-infra.repo && \
\
# Update your yum cache \
sudo yum -q makecache -y --disablerepo='*' --enablerepo='newrelic-infra' && \
\
# Run the installation script \
sudo yum install newrelic-infra -y

Para obter mais detalhes sobre o agente e sobre o processo de instalação e configuração, acesse os links abaixo que usei como referência.

Como coletar logs do NGINX com o Filebeat

Beatriz Oliveira — Mon, 04 Jan 2021 12:01:09 +0000

O que é o NGINX?

O NGINX é um servidor web open source que também pode ser utilizado como load balancer HTTP, proxy de e-mail (IMAP, POP3 e SMTP) e também como proxy reverso.

Para conhecer mais sobre o projeto, acesse a sua página oficial aqui.

Utilizando o Filebeat para coletar os logs do NGINX

Ao utilizar o módulo NGINX do Filebeat você consegue coletar e analisar os logs de erro e acesso que são criados pelo NGINX.
Para saber mais sobre esse módulo, acesse a documentação aqui

Instalação e configuração do Filebeat

Instale o Filebeat:

Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1
Linux: sudo rpm -vi filebeat-7.10.1-x86_64.rpm

Acesse o arquivo de configuração do Filebeat:

Windows: C:\Program Files\Filebeat\filebeat.yml
Linux: /etc/filebeat/filebeat.yml

Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable nginx
Linux: sudo filebeat modules enable nginx
Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable nginx
Linux: sudo filebeat modules enable nginx
Para modificar as configurações do módulo, altere o arquivo nginx.yml:

Windows: modules.d/nginx.yml
Linux: /etc/filebeat/modules.d/nginx.yml

Por padrão, o arquivo vem com as seguintes informações e é aqui que você especifica o caminho para o seu diretório de logs:

# Module: nginx
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.10/filebeat-module-nginx.html
- module: nginx
  # Access logs
  access:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/diretório/do/log/nginx/access.log*"]
# Error logs
  error:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/diretório/do/log/nginx/error.log*"]
# Ingress-nginx controller logs. This is disabled by default. It could be used in Kubernetes environments to parse ingress-nginx logs
  ingress_controller:
    enabled: false
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/diretório/do/log/nginx/ingress.log"]

Carregue os dashboards do módulo:

Windows: .\filebeat.exe setup
Linux: sudo filebeat setup

Inicie o serviço do Filebeat:

Windows: Start-Service filebeat
Linux: sudo service filebeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do seu NGINX.

Como coletar logs do MongoDB com o Filebeat

Beatriz Oliveira — Thu, 31 Dec 2020 14:24:09 +0000

O que é o MongoDB?

O MongoDB é um software banco de dados orientado a documentos, que é opensource e é desenvolvivido pela MongoDB Inc e é classificado como um banco NoSQL (Não Relacional).

Para conhecer mais sobre o projeto, acesse o site oficial dele aqui.

Também recomendo a leitura do post SQL ou NoSQL? no blog da Dani Monteiro, onde ela explica as diferenças de um banco de dados SQL e NoSQL e mostra alguns conceitos sobre o MongoDB.

Como coletar logs do MongoDB com o Filebeat

O módulo Mongo DB coleta logs que são criados pelo MongoDB. Para saber mais sobre esse módulo, acesse a documentação nesse link

Instale o Filebeat:

Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1
Linux: sudo rpm -vi filebeat-7.10.1-x86_64.rpm

Acesse o arquivo de configuração do Filebeat:

Windows: C:\Program Files\Filebeat\filebeat.yml
Linux: /etc/filebeat/filebeat.yml

Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable mongodb
Linux: sudo filebeat modules enable mongodb
Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable mongodb
Linux: sudo filebeat modules enable mongodb
Para modificar as configurações do módulo, altere o arquivo mongodb.yml:

Windows: modules.d/mongodb.yml
Linux: /etc/filebeat/modules.d/mongodb.yml

Por padrão, o arquivo vem com as seguintes informações e é aqui que você especifica o caminho para o seu diretório de logs:

# Module: mongodb
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.10/filebeat-module-mongodb.html
- module: mongodb
  # All logs
  log:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/diretório/do/log/mongodb/*.log*"]

Carregue os dashboards do módulo:

Windows: .\filebeat.exe setup
Linux: sudo filebeat setup

Inicie o serviço do Filebeat:

Windows: Start-Service filebeat
Linux: sudo service filebeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do seu MongoDB.

Como coletar logs de erro e queries lentas do MySQL com o Filebeat

Beatriz Oliveira — Tue, 29 Dec 2020 12:22:25 +0000

O que é o MySQL?

O MySQL é um sistema de gerenciamento de base de dados relacional que usa a linguagem SQL (Structured Query Language). Ele é open source e é desenvolvido e suportado pela Oracle.

Para conhecer mais sobre ele, acesse o site oficial do projeto nesse link.

Sobre o módulo MySQL do Filebeat

O módulo MySQL do Filebeat coleta os logs de erro e também de queries lentas que são criados pelo MySQL. É de extrema importância identificar essas informações de uma maneira rápida e eficiente para evitar que se tenha problemas com performance no seu ambiente.

Para saber mais sobre o módulo, acesse a documentação oficial no nesse link.

Instalação e configuração do Filebeat

Para instalar o Filebeat nos hosts, siga os passos descritos abaixo.

Faça o download do Filebeat nesse link.

Instale o Filebeat:

Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-filebeat.ps1
Linux: sudo rpm -vi filebeat-7.10.1-x86_64.rpm

Acesse o arquivo de configuração do Filebeat:

Windows: C:\Program Files\Filebeat\filebeat.yml
Linux: /etc/filebeat/filebeat.yml

Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo :
Windows: .\filebeat.exe modules enable mysql
Linux: sudo filebeat modules enable mysql
Para modificar as configurações do módulo, altere o arquivo mysql.yml:

Windows: modules.d/mysql.yml
Linux: /etc/filebeat/modules.d/mysql.yml

Por padrão, o arquivo vem com as seguintes informações e é aqui que você especifica o caminho para o seu diretório de logs:

# Module: mysql
# Docs: https://www.elastic.co/guide/en/beats/filebeat/7.10/filebeat-module-mysql.html
- module: mysql
  # Error logs
  error:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/path/to/log/mysql/error.log*"]
# Slow logs
  slowlog:
    enabled: true
# Set custom paths for the log files. If left empty,
    # Filebeat will choose the paths depending on your OS.
    #var.paths: ["/path/to/log/mysql/error.log*"]

Carregue os dashboards do módulo:

Windows: .\filebeat.exe setup
Linux: sudo filebeat setup

Inicie o serviço do Filebeat:

Windows: Start-Service filebeat
Linux: sudo service filebeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas dos logs de erro e lentos do seu MySQL.

Como coletar métricas do Windows utilizando o Metricbeat

Beatriz Oliveira — Wed, 23 Dec 2020 12:10:44 +0000

Nesse tutorial vamos construir uma monitoração básica do Windows utilizando o módulo Windows do Metricbeat, que é um agente da Elastic que coleta métricas de diversas plataformas, como já mostramos aqui no blog em outros posts.

Esse módulo que utilizaremos coleta o status dos serviços e também dados de performance em hosts Windows.

Caso você queira monitorar os logs e dados do Event Viewer por exemplo, recomendo fortemente o uso do Winlogbeat, que coleta logs de eventos do Windows perfeitamente.

Aqui no blog nós já fizemos um post mostrando como instalar e configurar o Winlogbeat e você pode acessar ele aqui.

Como instalar o Metricbeat e configurar o módulo Windows

Para começar esse lab, você precisará ter um ambiente com um host Windows e outro ambiente com o Elasticsearch e com o Kibana configurados.

Assim que você tiver esses pré requisitos, poderá começar a seguir os passos abaixo para configurar o Metricbeat para coletar as métricas do Windows.

Para instalar o Metricbeat nos hosts, siga os passos descritos abaixo.

Faça o download do Metricbeat nesse link.
Instale o Metricbeat:
Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-metricbeat.ps1
Linux: sudo rpm -vi metricbeat-7.10.1-x86_64.rpm
Acesse o arquivo de configuração do Metricbeat:
Windows: C:\Program Files\Metricbeat\metricbeat.yml
Linux: /etc/metricbeat/metricbeat.yml
Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo do Windows:
Windows: .\metricbeat.exe modules enable windows
Linux: sudo metricbeat modules enable windows
Para modificar as configurações do módulo, altere o arquivo windows.yml:
Windows: modules.d/windows.yml
Linux: /etc/metricbeat/modules.d/windows.yml

Por padrão, o arquivo vem com as seguintes informações:

metricbeat.modules:
- module: windows
  metricsets: ["perfmon"]
  enabled: true
  period: 10s
  perfmon.ignore_non_existent_counters: false
  perfmon.group_measurements_by_instance: false
  perfmon.queries:
#  - object: 'Process'
#    instance: ["*"]
#    counters:
#    - name: '% Processor Time'
#      field: cpu_usage
#      format: "float"
#    - name: "Thread Count"

- module: windows
  metricsets: ["service"]
  enabled: true
  period: 60s

Crie o índice do Metricbeat e carregue os dashboards:
Windows: .\metricbeat.exe setup
Linux: sudo metricbeat setup
Inicie o serviço do Metricbeat:
Windows: Start-Service metricbeat
Linux: sudo service metricbeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do estado do seu host Windows.

Métricas

Logs

Para saber mais sobre esse módulo do Metricbeat, acesse a documentação oficial da Elastic.

Como monitorar o Prometheus com Metricbeat

Beatriz Oliveira — Tue, 22 Dec 2020 21:02:22 +0000

O que é o Prometheus?

O Prometheus é uma ferramenta de monitoramento de métricas e indicadores de aplicações e serviços.

Segundo a descrição no Github do Prometheus:

"Ele coleta as métricas dos pontos configurados em intervalos dados, avalia expressões das regras, exibe os resultados e também pode acionar alertas quando as condições especificadas são observadas como verdadeiras."

Para saber mais sobre o projeto, acesse o site oficial do Prometheus.

Como monitorar o Prometheus utilizando o Metricbeat?

Para começar esse lab, você precisará ter um ambiente com o Prometheus e outro ambiente com o Elasticsearch e com o Kibana configurados.

Assim que você tiver esses pré requisitos, poderá começar a seguir os passos abaixo para configurar o Metricbeat para coletar os dados do Prometheus.

Para instalar o Metricbeat no host do Prometheus, siga os passos descritos abaixo.

Faça o download do Metricbeat nesse link.
Instale o Metricbeat:
Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-metricbeat.ps1
Linux: sudo rpm -vi metricbeat-7.10.1-x86_64.rpm
Acesse o arquivo de configuração do Metricbeat:
Windows: C:\Program Files\Metricbeat\metricbeat.yml
Linux: /etc/metricbeat/metricbeat.yml

Insira nele as informações de conexão com o Elasticsearch e com o Kibana.

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Se você estiver usando o Metricbeat OSS insira as seguintes configurações no fim do arquivo metricbeat.yml.

setup.ilm.enabled: false
setup.pack.security.enabled: false
setup.xpack.graph.enabled: false
setup.xpack.watcher.enabled: false
setup.xpack.monitoring.enabled: false
setup.xpack.reporting.enabled: false

Habilite e configure o módulo do Prometheus:
Windows: .\metricbeat.exe modules enable prometheus
Linux: sudo metricbeat modules enable prometheus
Para modificar as configurações do módulo, altere o arquivo prometheus.yml:
Windows: modules.d/prometheus.yml
Linux: /etc/metricbeat/modules.d/prometheus.yml

Por padrão, o arquivo vem assim:

# Module: prometheus
# Docs: https://www.elastic.co/guide/en/beats/metricbeat/7.8/metricbeat-module-prometheus.html
# Metrics collected from a Prometheus endpoint
- module: prometheus
  period: 10s
  metricsets: ["collector"]
  hosts: ["localhost:9090"]
  metrics_path: /metrics
  #metrics_filters:
  #  include: []
  #  exclude: []
  #username: "user"
  #password: "secret"
# This can be used for service account based authorization:
  #bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
  #ssl.certificate_authorities:
  #  - /var/run/secrets/kubernetes.io/serviceaccount/service-ca.crt
# Metrics sent by a Prometheus server using remote_write option
#- module: prometheus
#  metricsets: ["remote_write"]
#  host: "localhost"
#  port: "9201"
# Secure settings for the server using TLS/SSL:
  #ssl.certificate: "/etc/pki/server/cert.pem"
  #ssl.key: "/etc/pki/server/cert.key"
# Metrics that will be collected using a PromQL
#- module: prometheus
#  metricsets: ["query"]
#  hosts: ["localhost:9090"]
#  period: 10s
#  queries:
#  - name: "instant_vector"
#    path: "/api/v1/query"
#    params:
#      query: "sum(rate(prometheus_http_requests_total[1m]))"
#  - name: "range_vector"
#    path: "/api/v1/query_range"
#    params:
#      query: "up"
#      start: "2019-12-20T00:00:00.000Z"
#      end:  "2019-12-21T00:00:00.000Z"
#      step: 1h
#  - name: "scalar"
#    path: "/api/v1/query"
#    params:
#      query: "100"
#  - name: "string"
#    path: "/api/v1/query"
#    params:
#      query: "some_value"

Carregue os dashboards do módulo:
Windows: .\metricbeat.exe setup
Linux: sudo metricbeat setup
Inicie o serviço do Metricbeat:
Windows: Start-Service metricbeat
Linux: sudo service metricbeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do estado do seu Prometheus.

Métricas

Logs

Monitore suas instâncias do EC2 na AWS com o AWS Module do Metricbeat

Beatriz Oliveira — Tue, 22 Dec 2020 19:58:11 +0000

O que é o EC2?

Através do Amazon Elastic Compute Cloud (Amazon EC2) é possível criar servidores virtuais na AWS. Ao utilizar o EC2 você pode subir a quantidade de instâncias que precisar, além de conseguir escalar e desescalar elas de acordo com a sua necessidade. Também é possível fazer configurações de rede, segurança e armazenamento nesses hosts.
Conheça mais sobre o EC2 no site da Amazon.

Como utilizar o módulo AWS do Metricbeat para monitorar suas instâncias EC2

Através desse módulo AWS é possível coletar as métricas de monitoramento do Cloudwatch e enviar elas para o Elasticsearch, esse é um jeito alternativo de monitorar suas instâncias, pois você também poderia usar o módulo System para monitorar elas, a diferença é que para usar o módulo System, você teria que configurar ele em todos os hosts do seu ambiente, já o módulo AWS Metrics te permite executar ele apenas em um host.

Para começar esse lab, você precisará ter um ambiente com um host EC2 e outro ambiente com o Elasticsearch e com o Kibana configurados.

Assim que você tiver esses pré requisitos, poderá começar a seguir os passos abaixo para configurar suas permissões na AWS, configurar o Metricbeat para coletar os dados das instâncias EC2.

Criação do usuário e política na Amazon

Para ter acesso as informações do seu ambiente na AWS vai ser necessário que você crie um usuário para ter uma Access Key e uma Secret Key. Acesse o IAM no console da AWS, crie um usuário e salve a Access Key a Secret Key.
Depois de criar o usuário, você precisará criar uma politica do IAM com os seguintes níveis de acesso:

Cloudwatch: ListMetrics e GetMetricData

EC2: DescribeRegions e DescribeInstances

Por fim revise e crie a política como mostra a imagem abaixo.
Atribua a política que você criou ao usuário que você vai usar.

Instalação e configuração do Metricbeat

Para instalar o Metricbeat nos hosts, siga os passos descritos abaixo.

Faça o download do Metricbeat nesse link.
Instale o Metricbeat:
Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-metricbeat.ps1
Linux: sudo rpm -vi metricbeat-7.10.1-x86_64.rpm
Acesse o arquivo de configuração do Metricbeat:
Windows: C:\Program Files\Metricbeat\metricbeat.yml
Linux: /etc/metricbeat/metricbeat.yml
Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Habilite e configure o módulo da AWS:
Windows: .\metricbeat.exe modules enable aws
Linux: sudo metricbeat modules enable aws
Para modificar as configurações do módulo, altere o arquivo aws.yml:
Windows: modules.d/aws.yml
Linux: /etc/metricbeat/modules.d/aws.yml

Por padrão, o arquivo vem com as seguintes informações:

# Module: aws
# Docs: https://www.elastic.co/guide/en/beats/metricbeat/7.10/metricbeat-module-aws.html
- module: aws
  period: 1m
  metricsets:
    - elb
    - natgateway
    - rds
    - transitgateway
    - usage
    - vpn
- module: aws
  period: 5m
  metricsets:
    - cloudwatch
  metrics:
    - namespace: AWS/EC2
      #name: ["CPUUtilization", "DiskWriteOps"]
      resource_type: ec2:instance
      #dimensions:
      #  - name: InstanceId
      #    value: i-0686946e22cf9494a
      #statistic: ["Average", "Maximum"]
- module: aws
  period: 5m
  metricsets:
    - dynamodb
    - ebs
    - ec2
    - lambda
    - rds
    - sns
    - sqs
- module: aws
  period: 24h
  metricsets:
    - billing
  cost_explorer_config:
    group_by_dimension_keys:
      - "AZ"
      - "INSTANCE_TYPE"
      - "SERVICE"
#    group_by_tag_keys:
#      - "aws:createdBy"
- module: aws
  period: 24h
  metricsets:
    - s3_daily_storage
- module: aws
  period: 1m
  latency: 5m
  metricsets:
    - s3_request

Também insira nele as credenciais de acesso a AWS que você criou anteriormente:

metricbeat.modules:
- module: aws
  period: 300s
  metricsets:
    - "ec2"
  access_key_id: '${AWS_ACCESS_KEY_ID:"SUA ACCESS KEY"}'
  secret_access_key: '${AWS_SECRET_ACCESS_KEY:"SUA SECRET KEY"}'
  default_region: '${AWS_REGION:us-east-1}'

Carregue os dashboards do módulo:
Windows: .\metricbeat.exe setup
Linux: sudo metricbeat setup
Inicie o serviço do Metricbeat:
Windows: Start-Service metricbeat
Linux: sudo service metricbeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do estado das suas instâncias na Amazon.

Logs

Métricas

Como monitorar o Apache Zookeeper com o Metricbeat

Beatriz Oliveira — Mon, 21 Dec 2020 12:58:49 +0000

O que é o Apache Zookeeper

O Apache ZooKeeper é um software com a Licença Apache 2.0 da Apache Software Foundation.

Ele é um serviço centralizado voltado para grandes sistemas distribuídos e através dele é possível manter informações de configuração, registro de nomenclatura e fornecer sincronização distribuída por exemplo.

"A arquitetura do ZooKeeper suporta alta disponibilidade através de serviços redundantes. Os clientes podem, assim, pedir a outro líder do ZooKeeper se o primeiro não responder. Os nós do ZooKeeper armazenam seus dados em um espaço de nomes hierárquico, muito parecido com um sistema de arquivos ou uma estrutura de dados em árvore. Os clientes podem ler e gravar nos nós e, desse modo, ter um serviço de configuração compartilhado. O ZooKeeper pode ser visto como um sistema de transmissão atômica, através do qual as atualizações são totalmente ordenadas. O protocolo ZooKeeper Atomic Broadcast (ZAB) é o núcleo do sistema."
Referência: Instalando SolrCloud com Zookeeper Externo de Rodrigo Floriano

Para saber mais sobre o projeto, acesse o site oficial e a sua wiki.

Como monitorar o Apache Zookeeper utilizando o Metricbeat?

Para começar esse lab, você precisará ter um ambiente com o Zookeeper de preferência em uma versão >= 3.4.0 e outro ambiente com o Elasticsearch e com o Kibana configurados.

Assim que você tiver esses pré requisitos, poderá começar a seguir os passos abaixo para configurar o Metricbeat para coletar os dados do Zookeeper.

Para instalar o Metricbeat nos hosts do Zookeeper, siga os passos descritos abaixo.

Faça o download do Metricbeat nesse link.
Instale o Metricbeat:
Windows: PowerShell.exe -ExecutionPolicy UnRestricted -File .\install-service-metricbeat.ps1
Linux: sudo rpm -vi metricbeat-7.10.1-x86_64.rpm
Acesse o arquivo de configuração do Metricbeat:
Windows: C:\Program Files\Metricbeat\metricbeat.yml
Linux: /etc/metricbeat/metricbeat.yml
Insira nele as informações de conexão com o Elasticsearch e com o Kibana:

output.elasticsearch:
  hosts: ["url_do_elasticsearch:9200"]
setup.kibana:
  host: ["url_do_kibana:5601"]

Se você estiver usando o Metricbeat OSS insira as seguintes configurações no fim do arquivo metricbeat.yml:

# Set to true to enable the monitoring reporter.
#monitoring.enabled: false
setup.ilm.enabled: false
setup.pack.security.enabled: false
setup.xpack.graph.enabled: false
setup.xpack.watcher.enabled: false
setup.xpack.monitoring.enabled: false
setup.xpack.reporting.enabled: false

Habilite e configure o módulo do Apache Zookeeper:
Windows: .\metricbeat.exe modules enable zookeeper
Linux: sudo metricbeat modules enable zookeeper
Para modificar as configurações do módulo, altere o arquivo zookeeper.yml:
Windows: modules.d/zookeeper.yml
Linux: /etc/metricbeat/modules.d/zookeeper.yml

Por padrão, o arquivo vem com as seguintes informações:

# Module: zookeeper
# Docs: https://www.elastic.co/guide/en/beats/metricbeat/7.10/metricbeat-module-zookeeper.html
- module: zookeeper
  #metricsets:
  #  - mntr
  #  - server
  period: 10s
  hosts: ["localhost:2181"]

Carregue os dashboards do módulo:
Windows: .\metricbeat.exe setup
Linux: sudo metricbeat setup
Inicie o serviço do Metricbeat:
Windows: Start-Service metricbeat
Linux: sudo service metricbeat start

Depois disso, você conseguirá ver os logs do seu ambiente no discover, além de ter dashboards com informações e métricas do estado do seu Zookeeper.

Métricas

Logs

Para obter mais informações, acesse a documentação oficial desse módulo no site da Elastic.

Guia de como criar um cluster com o centralizador de logs Graylog 3.3

Thaynara Mendes — Thu, 08 Oct 2020 12:56:35 +0000

Heeey!

Fiz um lab utilizando a arquitetura do Graylog de alta disponibilidade e resolvi criar um guia com os passos que fiz nessa jornada.

Na documentação do graylog essa configuração se chama "Multi-node Setup". Utilizaremos 3 servidores com Graylog e MongoDB, 3 servidores com Elasticsearch e 1 com HAProxy.

Para ter uma ideia. Nossa arquitetura vai ficar desta forma:

OBS:Os servidores foram criados com a distro CentOS 7. Logo, se fizer em outra distro vai ter que rever os processo de instalação. Vamos lá ;)

Elasticsearch

O Elasticsearch é o mecanismo de busca e análise de dados que o Graylog utiliza para indexar os logs recebidos.

Instalação

O Graylog apenas suporta até a versão 6.x do Elasticsearch.

eu que sempre instalo a última versão das coisas descobri isso após ter finalizado o cluster </3

Um pré-requisito para todos servidores é o java. Então vamos começar por ele.

yum update && yum -y install java-1.8.0-openjdk-headless.x86_64

Para a instalação do Elasticsearch, vamos importar a Elastic GPG key.

rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

E adicionar o arquivo elasticsearch.repo no /etc/yum.repos.d/.

$ vim elasticsearch.repo
[elasticsearch-6.x]
name=Elasticsearch repository for 6.x packages
baseurl=https://artifacts.elastic.co/packages/oss-6.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md

Após isso basta instalar

yum install elasticsearch-oss

Configuração

Como os meus servidores eu coloquei o mínimo de RAM (1G) precisei mudar algumas opções do Java, limitando o uso de memória dele. Caso tiver mais que 1G não precisa fazer essa etapa.
Altere as linhas:

$ vim /etc/elasticsearch/jvm.options
-Xms512m
-Xmx512m

Edite o arquivo de configuração:

$ vim /etc/elasticsearch/elasticsearch.yml
cluster.name: graylog
node.name: ${HOSTNAME}
network.host: 0.0.0.0
http.port: 9200
discovery.zen.ping.unicast.hosts: ["elastic1.lab", "elastic2.lab", "elastic3.lab"]

OBS: Para ficar melhor a identificação dos servers, configurei o DNS no /etc/hosts

Após configurar basta subir o serviço:

systemctl daemon-reload
systemctl enable elasticsearch.service
systemctl restart elasticsearch.service

Você consegue checar o status do Elasticsearch através do curl:

$ curl http://elastic1.lab:9200 
{
  "name" : "elastic1",
  "cluster_name" : "graylog",
  "cluster_uuid" : "qMtqk9hUTcm9gT8a6wF7-w",
  "version" : {
    "number" : "6.8.12",
    "build_flavor" : "oss",
    "build_type" : "rpm",
    "build_hash" : "7a15d2a",
    "build_date" : "2020-08-12T07:27:20.804867Z",
    "build_snapshot" : false,
    "lucene_version" : "7.7.3",
    "minimum_wire_compatibility_version" : "5.6.0",
    "minimum_index_compatibility_version" : "5.0.0"
  },
  "tagline" : "You Know, for Search"
}

No meu caso não foi de primeira, por um bloqueio do SELinux. Então caso não conseguir verifique se o SELinux ou o firewall está bloqueando a conexão.

Você pode apenas desabilitar o firewall ou deixá-lo ativo e liberar a conexão do elasticsearch.

Para desabilitar basta rodar o comando:

$ systemctl disable firewalld

Após replicar esses processos nos outros dois servidores, o nosso cluster do Elasticsearch estará pronto!

MongoDB

OBS: Agora vamos configurar 3 servidores com mongo e Graylog, então recomendo no mínimo 2G

O MongoDB é um serviço de banco de dados NoSQL que o Graylog utiliza para armazenar os dados de configuração.

Instalação

Crie um arquivo mongodb-org-4.4.repo no /etc/yum.repos.d/

$ vim mongodb-org-4.4.repo
[mongodb-org-4.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc

Após isso basta instalar
yum update && yum install -y mongodb-org

Configuração

Crie os diretórios:

mkdir -p /var/lib/mongo
mkdir -p /var/log/mongodb
mkdir -p /data/db

Configure as permissões do usuário mongod:

chown -R mongod:mongod /var/lib/mongo
chown -R mongod:mongod /var/log/mongodb

Na documentação do mongo, tem uma seção para configurar a política do SELinux para que permita os acessos. Caso sua distro não use SELinux, pode pular essa etapa.

$ yum install checkpolicy policycoreutils-python

cat > mongodb_cgroup_memory.te <<EOF
module mongodb_cgroup_memory 1.0;

require {
    type cgroup_t;
    type mongod_t;
    class dir search;
    class file { getattr open read };
}

#============= mongod_t ==============
allow mongod_t cgroup_t:dir search;
allow mongod_t cgroup_t:file { getattr open read };
EOF

$ checkmodule -M -m -o mongodb_cgroup_memory.mod mongodb_cgroup_memory.te
$ semodule_package -o mongodb_cgroup_memory.pp -m mongodb_cgroup_memory.mod
$ semodule -i mongodb_cgroup_memory.pp

Após configurar basta subir o serviço:

$ systemctl daemon-reload
$ systemctl enable mongod
$ systemctl start mongod

Você consegue testar a conexão rodando:

mongo

OBS:Caso mostrar alguma falha, verifique o firewall.

Para a configuração das réplicas do mongo basta executar (antes é preciso parar a instancia do mongod que está rodando):

mongod  --replSet "rs0" --bind_ip localhost,mongodb1.lab --fork --logpath /var/log/mongodb/mongod

Sobre o esta linha de comando:

mude mongodb1.lab para o endereço do server
--fork é para que o processo seja executado em segundo plano
--replSet para inserir o nome da configuração de replicação.

Após fazer esses procedimentos nos 3 servers. Em apenas um, conecte ao mongo shell:

$ mongo

e inicialize a configuração da replica:

rs.initiate( {
   _id : "rs0",
   members: [
      { _id: 0, host: "mongodb1.devops.lab:27017" },
      { _id: 1, host: "mongodb2.devops.lab:27017" },
      { _id: 2, host: "mongodb3.devops.lab:27017" }
   ]
})

você consegue verificar a configuração rodando:

rs.status()

a saída deve estar mais ou menos desta forma:

rs0:PRIMARY> rs.status()
{
        "set" : "rs0",
        "date" : ISODate("2020-10-07T04:23:25.190Z"),
        "myState" : 1,
        "term" : NumberLong(12),
        "syncSourceHost" : "",
        "syncSourceId" : -1,
        "heartbeatIntervalMillis" : NumberLong(2000),
        "majorityVoteCount" : 2,
        "writeMajorityCount" : 2,
        "votingMembersCount" : 3,
        "writableVotingMembersCount" : 3,
        "optimes" : {
                "lastCommittedOpTime" : {
                        "ts" : Timestamp(1602044601, 9),
                        "t" : NumberLong(12)
                },
                "lastCommittedWallTime" : ISODate("2020-10-07T04:23:21.627Z"),
                "readConcernMajorityOpTime" : {
                        "ts" : Timestamp(1602044601, 9),
                        "t" : NumberLong(12)
                },
                "readConcernMajorityWallTime" : ISODate("2020-10-07T04:23:21.627Z"),
                "appliedOpTime" : {
                        "ts" : Timestamp(1602044604, 11),
                        "t" : NumberLong(12)
                },
                "durableOpTime" : {
                        "ts" : Timestamp(1602044602, 11),
                        "t" : NumberLong(12)
                },
                "lastAppliedWallTime" : ISODate("2020-10-07T04:23:24.975Z"),
                "lastDurableWallTime" : ISODate("2020-10-07T04:23:22.958Z")
        },
        "lastStableRecoveryTimestamp" : Timestamp(1602044492, 7),
        "electionCandidateMetrics" : {
                "lastElectionReason" : "electionTimeout",
                "lastElectionDate" : ISODate("2020-10-07T04:19:54.787Z"),
                "electionTerm" : NumberLong(12),
                "lastCommittedOpTimeAtElection" : {
                        "ts" : Timestamp(0, 0),
                        "t" : NumberLong(-1)
                },
                "lastSeenOpTimeAtElection" : {
                        "ts" : Timestamp(1601673721, 7),
                        "t" : NumberLong(11)
                },
                "numVotesNeeded" : 2,
                "priorityAtElection" : 1,
                "electionTimeoutMillis" : NumberLong(10000),
                "numCatchUpOps" : NumberLong(0),
                "newTermStartDate" : ISODate("2020-10-07T04:19:55.550Z"),
                "wMajorityWriteAvailabilityDate" : ISODate("2020-10-07T04:19:56.455Z")
        },
        "members" : [
                {
                        "_id" : 0,
                        "name" : "mongodb1.devops.lab:27017",
                        "health" : 1,
                        "state" : 1,
                        "stateStr" : "PRIMARY",
                        "uptime" : 424,
                        "optime" : {
                                "ts" : Timestamp(1602044604, 11),
                                "t" : NumberLong(12)
                        },
                        "optimeDate" : ISODate("2020-10-07T04:23:24Z"),
                        "syncSourceHost" : "",
                        "syncSourceId" : -1,
                        "infoMessage" : "",
                        "electionTime" : Timestamp(1602044395, 1),
                        "electionDate" : ISODate("2020-10-07T04:19:55Z"),
                        "configVersion" : 1,
                        "configTerm" : 12,
                        "self" : true,
                        "lastHeartbeatMessage" : ""
                },
                {
                        "_id" : 1,
                        "name" : "mongodb2.devops.lab:27017",
                        "health" : 1,
                        "state" : 2,
                        "stateStr" : "SECONDARY",
                        "uptime" : 219,
                        "optime" : {
                                "ts" : Timestamp(1602044604, 6),
                                "t" : NumberLong(12)
                        },
                        "optimeDurable" : {
                                "ts" : Timestamp(1602044601, 9),
                                "t" : NumberLong(12)
                        },
                        "optimeDate" : ISODate("2020-10-07T04:23:24Z"),
                        "optimeDurableDate" : ISODate("2020-10-07T04:23:21Z"),
                        "lastHeartbeat" : ISODate("2020-10-07T04:23:24.801Z"),
                        "lastHeartbeatRecv" : ISODate("2020-10-07T04:23:25.012Z"),
                        "pingMs" : NumberLong(0),
                        "lastHeartbeatMessage" : "",
                        "syncSourceHost" : "mongodb1.devops.lab:27017",
                        "syncSourceId" : 0,
                        "infoMessage" : "",
                        "configVersion" : 1,
                        "configTerm" : 12
                },
                {
                        "_id" : 2,
                        "name" : "mongodb3.devops.lab:27017",
                        "health" : 1,
                        "state" : 2,
                        "stateStr" : "SECONDARY",
                        "uptime" : 212,
                        "optime" : {
                                "ts" : Timestamp(1602044604, 6),
                                "t" : NumberLong(12)
                        },
                        "optimeDurable" : {
                                "ts" : Timestamp(1602044601, 5),
                                "t" : NumberLong(12)
                        },
                        "optimeDate" : ISODate("2020-10-07T04:23:24Z"),
                        "optimeDurableDate" : ISODate("2020-10-07T04:23:21Z"),
                        "lastHeartbeat" : ISODate("2020-10-07T04:23:24.801Z"),
                        "lastHeartbeatRecv" : ISODate("2020-10-07T04:23:25.031Z"),
                        "pingMs" : NumberLong(1),
                        "lastHeartbeatMessage" : "",
                        "syncSourceHost" : "mongodb1.devops.lab:27017",
                        "syncSourceId" : 0,
                        "infoMessage" : "",
                        "configVersion" : 1,
                        "configTerm" : 12
                }
        ],
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Timestamp(1602044604, 11),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(1602044604, 11)
}

Crie um banco de dados e um usuário para o Graylog:

use graylog;
db.createUser( { user: "mongo_admin", pwd: "graylog", roles: [ { role: "root", db: "admin" } ] } )

Certo, com o Elasticsearch e o MongoDB configurados, vamos para o Graylog!

Graylog

Instalação

$ rpm -Uvh https://packages.graylog2.org/repo/packages/graylog-3.3-repository_latest.rpm
$ yum update && yum -y install java-1.8.0-openjdk-headless.x86_64 graylog-server

Configuração

Você também consegue alterar o uso de memória do Java, o arquivo de configuração dessas opções que fica em /etc/sysconfig/graylog-server.

Antes de editar o arquivo de configuração, você irá precisar gerar duas senhas.

Para gerar a password_secret basta rodar o comando:

pwgen -N 1 -s 96

obs: caso não tenha o pwgen instalado basta seguir esses passos:

$ yum install epel-release
$ yum install pwgen

Para gerar a root_password_sha2, rode esse comando:

echo -n "Enter Password: " && head -1 </dev/stdin | tr -d '\n' | sha256sum | cut -d" " -f1

Após isso, edite o arquivo de configuração:

$ vim /etc/graylog/server/server.conf
is_master = true
password_secret = [gerada anteriormente]
root_password_sha2 = [gerada anteriormente]
root_timezone = America/Sao_Paulo
http_bind_address = graylog1.lab:9000
http_publish_uri = http://graylog.1.lab:9000/
elasticsearch_hosts = http://elastic1.lab:9200,http://elastic2.lab:9200,http://elastic3.lab:9200
elasticsearch_shards = 3
mongodb_uri = mongodb://mongo_admin:graylog@mongodb1.lab:27017,mongodb2.lab:27017,mongodb3.lab:27017/graylog?replicaSet=rs0

obs:

apenas deixe is_master = true em um dos servidores
modifique web.graylog1 para o endereço do server
modifique a linha elasticsearch_hosts com os endereços dos servidores do elasticsearch
modifique a linha mongodb_uricom os endereços dos servidores do mongo

Agora basta subir o server do graylog:

$ systemctl daemon-reload
$ systemctl enable graylog-server
$ systemctl start graylog-server

Após alguns minutos você irá conseguir acessar o endereço do graylog http://graylog1.lab:9000/. O login é admin e a senha é a que você inseriu no campo root_password_sha2.

HAProxy

o HAProxy vai servir como um balanceador de carga para o nosso cluster. Isso quer dizer que ao configurar o envio de logs, nós iremos mandar para o endereço do servidor que está o HAProxy e ele que vai ser o responsável por enviar para os servidores do graylog.

Instalação

yum update && yum install haproxy

Configuração

Edite o arquivo de configuração e insira os blocos:

$ vim /etc/haproxy/haproxy.cfg

listen stats
   bind :32700
   stats enable
   stats uri /
   stats hide-version
   stats auth devops:devopslab

listen syslog_1514
   bind *:1514
   mode tcp
   option tcplog
   timeout client 120s
   timeout server 120s
   default-server inter 2s downinter 5s rise 3 fall 2 maxconn 64 maxqueue 128 weight 100
   server graylog1 graylog1.lab:1514 check
   server graylog2 graylog2.lab:1514 check
   server graylog3 graylog3.lab:1514 check

O primeiro bloco é para a página de estatísticas que o HAProxy exibe, ao acessá-la você conseguirá ver o balanceamento de dados entres os servidores do graylog. Basta acessar o endereço do server na porta 32700:

O segundo bloco é a configuração da porta onde o HAProxy irá "ouvir" e depois realizar o balanceamento entre os servers. O "check" é para que ele verifique se o server está up antes de enviar.

Enviando log para o Graylog

Você consegue enviar praticamente qualquer log de sistema para o servidor do graylog. Neste guia eu vou demonstrar apenas como configurar o envio utilizando o rsyslog.

Para outros tipos de log, você pode utilizar o Graylog Sidecar, é um serviço que roda em segundo plano coletando logs que deseja enviar para a API do Graylog.

O primeiro passo para isso é configurar o Input na API do graylog, ele é o responsável por criar uma porta específica para os variados tipos de log.

Acesse a API do Graylog (no meu caso http://graylog1.lab:9000/) e siga os passos:

Vá em System
Depois em Inputs
Selecione SysLog TCP
Selecione Launch new Input

Ao seguir esses passos irá abrir uma janela para que preencha os detalhes do Input então vamos preencher os campos:

Marque a opção Global
Title: “Log Syslog”
Bind address: 0.0.0.0
Port:1514
Clique em Salvar.

Ao clicar em salvar, verá que o status do input passará de NOT RUNNING para RUNNING.

Agora que você já configurou o input, basta configurar o rsyslog da máquina que irá enviar os logs:

$ vim /etc/rsyslog.d/graylog.conf
*.* @@web.graylog.lab:1514;RSYSLOG_SyslogProtocol23Format

obs:Troque web.graylog.lab para o endereço do servidor do HAProxy

Reinicie o serviço

systemctl restart rsyslog

Após todos esses passos, ao acessar a API do Graylog, na aba Search você conseguirá visualizar, fazer consultas e criar dashboards personalizadas :)

última observação: Quando lidamos com cluster é muito importante que todos os servidores estejam com o mesmo horário, a divergência pode gerar erros no graylog.

Vlw pessoal! \o/

O Centro de Dados

Mariana Carvalho — Thu, 06 Aug 2020 02:26:01 +0000

Para falarmos sobre infraestrutura, precisamos entender alguns conceitos importantes.

Todos os dados, apesar de residirem em um mundo totalmente virtual, são, na verdade, “bits” e “bytes” que estão armazenados em um espaço físico e são, portanto, matéria física. Para isso, os dados precisam estar armazenados em algum lugar, ou em o que chamamos de “centro de dados”.
Um centro de dados (data center, em inglês) é um espaço físico, onde empresas, universidades, hospitais e instituições armazenam suas aplicações, banco de dados, servidores e switches.

Na última década, temos visto empresas se reinventando e navegando no que chamamos de Transformação Digital.

Cada vez mais, empresas, tanto públicas quanto privadas, estão percebendo que possuem um ativo muito valioso: os dados de seus usuários, funcionários e consumidores. Segundo um artigo da Forbes publicado em inglês, em Novembro de 2019 “data is the new oil” ou, em tradução literal, “os dados são os novos óleos (ou petróleo, no caso)”. De fato são.

A Transformação Digital pode ser entendida como a utilização de recursos digitais para alterar produtos, aplicações e a maneira como as organizações operam e interagem com o consumidor final. A Transformação Digital está relacionada à mudança e à disrupção digital em que empresas se utilizam de software e desenvolvimento tecnológico para conectar aparelhos com novos serviços.

O escopo da Transformação Digital está baseado em um novo design e infraestrutura na qual empresas se utilizam de dados a nível da interface com seus usuários finais (sejam eles internos ou externos à organização).

O Centro de Dados é responsável por armazenar, processar, proteger e, através de suas aplicações e times de experts, transformar os dados em inteligência.

O Centro de Dados é desenhado para prover recursos de processamento e armazenamento para aplicações e banco de dados, por meio de conexões de rede. Ele também deve ser desenhado e arquitetado para que seja o mais eficiente possível.

Componentes

O Centro de Dados é composto por:

Servidores

Switches

Roteadores

Firewalls

Hardware de armazenamento (discos)

Energia

Refrigeração

Centro de Dados e Eficiência Energética

Um Centro de Dados deve ser desenhado levando-se em consideração seu consumo consciente de energia elétrica, com o objetivo de utilizar ao máximo seus recursos físicos, além de considerar seu impacto energético e no meio ambiente.

Para entender realmente os requisitos de energia do data center, é útil conhecer algumas terminologias básicas para sistemas elétricos:

Amperes: Uma medida da corrente elétrica real que se move através de uma linha de energia. Os dispositivos têm uma classificação com base no número de amplificadores que podem usar ou suportar. Uma classificação de amplificador mais alta em um dispositivo significa que mais energia pode ser utilizada antes de ser sobrecarregada

Volts: comparáveis à pressão da água em um tubo, os volts medem a força elétrica necessária para empurrar 1 ampere através de um fio ou condutor elétrico. Uma voltagem mais alta permite que mais energia seja transferida através de um circuito

Ohms: a resistência que diminui a corrente elétrica e causa impedimentos. Mantendo a analogia da água, a alteração de ohms seria comparável à alteração do tamanho do tubo. Ohms mais baixos permitem que mais corrente viaje pelo circuito, mas requerem uma tensão mais alta para empurrar esses amplificadores adicionais

Watts: a potência mede a energia elétrica disponível para ser usada por um dispositivo. Watts é frequentemente medido em kWh ou MW

Pense em um circuito como uma torneira em uma pia. Se você quiser água, precisará se preocupar com: água para sair e pressão para forçá-la através dos canos. Da mesma forma, um circuito elétrico usa elétrons para transportar a eletricidade, mas esses elétrons precisam de algo para empurrá-los. Essa ‘pressão’ elétrica é o que chamamos de “tensão”.

Essa voltagem é fornecida pelas empresas de energia e, embora a voltagem meça a intensidade com que a eletricidade está sendo empurrada através de um circuito, é importante porque muitos circuitos são projetados para aceitar apenas um certo número de volts.

Os projetos tradicionais de distribuição de energia do datacenter consistem em unidades de distribuição de energia (Power Distribution Units, ou PDUs) que fornecem energia aos racks. À medida que o número de equipamentos montados em rack, como servidores, computadores e sistemas de armazenamento, aumenta, aumenta também a energia necessária para esse rack.

As PDUs lidam com essa complexidade de distribuição de energia, retirando a que foi fornecida ao rack e distribuindo-a por várias tomadas para os servidores e equipamentos de rede do rack. Do ponto de vista do projeto, é uma prática recomendada ter duas PDUs por rack para redundância de energia em caso de interrupção ou falha. Às vezes, as empresas utilizam duas empresas de fornecimento de energia diferentes para garantir alta disponibilidade de energia, cada uma fornecendo uma PDU separada.

Atualmente, existem dois tipos de disposição dos gabinetes (ou racks) que contém os servidores e os refrigeradores. Aqui estão suas definições:

Contenção do Corredor Quente: focado em canalizar o ar quente de exaustão liberado pelos servidores e equipamentos do Centro de Dados e direcioná-lo para a área onde se encontra o ar condicionado. Como, naturalmente, o ar quente tende a subir, ele é capturado pelo vazio no teto e, de lá, vai para o ar condicionado, sem se misturar com o ar frio.

Benefícios do Corredor Quente (Hot Aisle, em inglês): garante que o ar frio não seja comprometido pelo escapamento do ar quente e também garante que o ar quente chegue ao ar condicionado, fazendo com que este aumente sua capacidade de resfriamento, o que aumenta, ainda, a eficiência energética do centro de dados.

Referência da imagem aqui.

Contenção do Corredor Frio (ou Cold Aisle, em inglês): focado em criar um fluxo de ar frio nas passagens dos corredores e nas divisórias ao longo do teto ou chão. Esta implementação previne que o ar frio do ar condicionado saia para o exterior, eliminando também qualquer ponto quente que há dentro do corredor.

Benefícios do Corredor Frio: garante a utilização efetiva dos 15% da parte de cima dos racks, que, geralmente, são deixados em aberto/vazios. Com esse tipo de implementação de refrigeração, consegue-se utilizar todo o potencial de um rack, reduzindo o custo por metro quadrado do centro de dados.

Referência da imagem aqui.

Centro de Dados e Segurança

Como falamos anteriormente, o Centro de Dados armazena e protege todos os equipamentos e servidores que sustentam uma organização. Estes equipamentos e servidores, por sua vez, são responsáveis por armazenar o bem mais precioso das organizações: seus dados.

Assim, toda segurança se faz necessária: não somente a virtual, através de antivírus e firewalls — que serão discutidos no capítulo 15, mas também a segurança física desse Centro de Dados.

Segurança Física

A segurança física de um centro de dados tem como responsabilidade garantir a segurança dos equipamentos e prevenir qualquer tipo de acidente aos componentes físicos citados anteriormente.

Para isso, devem ser instaladas câmeras de segurança, com acesso somente permitido a pessoas autorizadas, que registre histórico de entrada e saída e agentes de segurança. Além dessas medidas de segurança, medidas reativas, como sistemas químicos para prevenção de incêndio e destruição dos aparelhos, são recomendadas.

Todo o cuidado, físico e virtual, é pouco perto do prejuízo financeiro que a perda de equipamentos pode trazer para uma organização. Por isso, todo o planejamento de um plano de segurança e prevenção é altamente recomendado em ambientes de centro de dados.

Seguindo a linha de proteção dos equipamentos, vamos falar, em nosso próximo capítulo, sobre Proteção de Dados, englobando a Recuperação de Desastres (RD), ou Disaster Recovery (DR), em inglês, e estratégias de backup e arquivamento. Caso queira aprender mais sobre segurança em um centro de dados, visite essa página da VMware.

Sugestões de livros:
O Projeto Fênix, de Gene Kim, Kevin Behr e George Spafford, da Editora Alta Books
Segurança no Centro de Dados, em inglês, da Amazon

Caso conheça outras indicações de livros, certificações ou cursos, fique à vontade para deixar nos comentários. Ficarei feliz em adicionar a esse post!

Esse texto faz parte do Guia de Infraestrutura de Tecnologia de Informação publicado no medium, no dev.to, e na Open Library. Para checar todos os capítulos, clique aqui e acesse a Introdução.

Próximo capítulo: Proteção de Dados