Como instalar o OpenSearch via Docker no Ubuntu 22.04

OpenSearch é um projeto conduzido pela comunidade da Amazon e um fork do Elasticsearch e Kibana. É um mecanismo de pesquisa e conjunto de análises totalmente de código aberto, com recursos avançados e funcionalidades inovadoras. O principal componente do projeto OpenSearch é o OpenSearch (um fork do Elasticsearch) e o OpenSearch Dashboards (um fork do Kibana). Ambos os componentes fornecem recursos como segurança empresarial, alertas, aprendizado de máquina, SQL, gerenciamento de estado de índice e muito mais.

OpenSearch é 100% de código aberto e licenciado sob licença Apache 2.0. Ele permite que você ingerir, proteger, pesquisar, agregar, visualizar e analisar dados com facilidade para vários casos de uso, como análise de log, pesquisa de aplicativos, pesquisa corporativa e muito mais.

Neste tutorial, você instalará e configurará o OpenSearch – um mecanismo de pesquisa e conjunto de análises de código aberto – e o OpenSearch Dashboards – uma ferramenta de visualização de código aberto – via Docker em um servidor Ubuntu 22.04. Você implantará um cluster OpenSearch com vários contêineres e um único painel OpenSearch via Docker e Docker Compose. Você também protegerá sua implantação com certificados TLS personalizados e autenticação e autorização habilitadas.

Este guia usa um novo servidor Ubuntu genérico, portanto, este tutorial inclui a instalação do mecanismo Docker e do Docker Compose em um sistema Ubuntu 22.04.

Pré-requisitos

Para concluir este guia, você deve ter os seguintes requisitos:

• Um servidor Ubuntu 22.04 com mínimo de RAM de 4 a 8 GB - Este exemplo usa um servidor Ubuntu com o nome de host '' e um endereço IP ''.
• Um usuário não root com privilégios de administrador sudo/root.

Quando esses requisitos estiverem prontos, você poderá iniciar a instalação do OpenSearch.

Configurando o sistema

Nesta primeira etapa, você preparará seu sistema Ubuntu para a implantação do OpenSearch. Você precisará desativar o SWAP e a paginação e, em seguida, aumentar o mapa máximo de memória por meio do arquivo '/etc/sysctl.conf'.

Execute o comando abaixo para desabilitar a troca em seu sistema. O comando 'sed' aqui desabilitará a troca permanentemente através do arquivo '/etc/fstab' adicionando o comentário '#' ao início da linha de configuração de troca. O comando 'swapoff' desativará a troca na sessão atual.

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
sudo swapoff -a

Em seguida, verifique o status da troca por meio do comando abaixo. Se desativado, você deverá obter uma saída '0' na seção de troca.

free -m

Saída :

Por último, você adicionará a configuração ao arquivo '/etc/sysctl.conf' para aumentar os mapas máximos de memória em seu sistema Ubuntu.

Execute o comando abaixo para adicionar o parâmetro 'vm.max_map_count=262144' ao final da linha do arquivo '/etc/sysctl.conf'. Em seguida, aplique as alterações por meio do comando 'sysctl -p'.

sudo echo "vm.max_map_count=262144" >> /etc/sysctl.conf
sudo sysctl -p

Agora verifique os mapas de memória máxima executando o comando abaixo. Se for bem-sucedido, seu mapa máximo de memória deverá ser '262144'.

cat /proc/sys/vm/max_map_count

Saída :

Com a troca desabilitada e o mapa máximo de memória aumentado para '262144', em seguida você iniciará a instalação do mecanismo Docker e do Docker Compose.

Instalando Docker CE e Docker Compose

Existem várias maneiras de implantar e instalar o OpenSearch, você pode instalar o OpenSearch de maneira tradicional em uma máquina virtual ou instalá-lo no ambiente de contêiner.

Se preferir a instalação tradicional em uma máquina virtual, você pode instalar o OpenSearch manualmente via Tarball ou através do gerenciador de pacotes (para distribuições baseadas em RHEL). Para implantação de contêiner, você pode instalar o OpenSearch com Docker e Kubernetes.

Neste exemplo, você instalará o OpenSearch no ambiente contêiner por meio do mecanismo Docker e do Docker Compose. Agora, você instalará pacotes Docker do repositório oficial do Docker.

Para começar, execute o comando apt abaixo para instalar dependências básicas. Insira y quando solicitado e pressione ENTER para continuar.

sudo apt install ca-certificates curl gnupg lsb-release

Saída :

Em seguida, execute o comando abaixo para adicionar a chave GPG e o repositório para pacotes Docker.

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Saída :

Depois disso, atualize e atualize seu índice de pacotes Ubuntu através do comando apt abaixo.

sudo apt update

Saída :

Com o repositório Docker adicionado, agora você pode instalar o mecanismo Docker e o plugin Docker Compose usando o comando apt abaixo. Quando solicitado, insira y e pressione ENTER para continuar.

sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Saída :

O serviço Docker será iniciado e ativado automaticamente. Você pode verificar o serviço Docker por meio do seguinte utilitário de comando systemctl.

sudo systemctl is-enabled docker
sudo systemctl status docker

Você deve obter uma saída informando que o serviço Docker está habilitado e será executado automaticamente na inicialização. E o status do serviço Docker está em execução.

Por último, para permitir que seu usuário não root execute o contêiner Docker, você deve adicionar seu usuário ao grupo 'docker'. Execute o comando usermod abaixo para adicionar seu usuário ao grupo 'docker'. Além disso, certifique-se de alterar o nome de usuário com o seu usuário.

sudo usermod -aG docker alice

Agora você pode fazer login como seu usuário e executar o contêiner Docker por meio do comando abaixo.

su - alice
docker run hello-world

Quando for bem-sucedido, você deverá receber a mensagem hello-world do contêiner Docker, como na captura de tela a seguir.

Baixando imagens do OpenSearch Docker

Nesta etapa, você baixará imagens do OpenSearch e do OpenSearch Dashboards do DockerHub. Em seguida, você também executará um novo contêiner OpenSearch para fins de teste.

Execute o comando a seguir para fazer download das imagens do OpenSearch e do OpenSearch Dashboards.

docker pull opensearchproject/opensearch:latest
docker pull opensearchproject/opensearch-dashboards:latest

Saída :

Após a conclusão dos downloads, execute o comando abaixo para verificar a lista de imagens Docker em seu sistema. Você verá que as imagens do OpenSearch e do OpenSearch Dashboards estão disponíveis em seu sistema.

docker images

Saída :

A seguir, você também pode executar o OpenSearch via Docker diretamente usando o comando abaixo. Isso criará e executará o contêiner OpenSearch em um único modo e exporá as portas TCP padrão 9200 e 9600 na máquina host.

docker run -d -p 9200:9200 -p 9600:9600 -e "discovery.type=single-node" opensearchproject/opensearch:latest

Verifique a lista do contêiner em execução por meio do comando 'docker ps' abaixo.

docker ps

Você deverá receber uma saída como esta – O contêiner OpenSearch foi criado e está em execução. Portas TCP 9200 e 9600 expostas no contêiner e no host Docker.

Você pode acessar seu contêiner OpenSearch por meio do comando curl abaixo. O nome de usuário e a senha padrão para o contêiner OpenSearch é 'admin'.

curl https://localhost:9200 -ku 'admin:admin'

Quando for bem-sucedido, você deverá obter uma saída como esta - O contêiner OpenSearch está em execução e acessível por meio da máquina host do Docker.

Agora você pode executar o comando ‘docker’ abaixo para parar e excluir o contêiner OpenSearch. Porque na próxima etapa, você criará um cluster OpenSearch por meio do Docker Compose. Certifique-se de alterar o nome do contêiner no comando a seguir.

docker stop container-name or container-id
docker rm container-name or container-id

Para garantir que o contêiner OpenSearch seja removido, execute o comando 'docker ps' com a opção adicional '-a'. Isso mostrará os contêineres disponíveis com ambos os status, em execução e encerrados.

docker ps -a

Saída :

Configurar diretório do projeto

Faça login em seu usuário com o seguinte comando. Este exemplo usa um usuário ‘alice’, então certifique-se de alterar o nome de usuário no comando abaixo.

su - alice

Agora crie um novo diretório de projeto 'opensearch-project' que será usado como o diretório raiz principal do seu projeto, e o diretório 'certs' que será usado para armazenar certificados TLS personalizados.

mkdir -p ~/opensearch-project/certs; cd ~/opensearch-project

Dentro do diretório 'opensearch-project', execute o comando abaixo para criar novos arquivos que serão usados para criar contêineres OpenSearch e os painéis OpenSearch.

touch docker-compose.yml opensearch.yml opensearch_dashboards.yml internal_users.yml

A lista de arquivos:

• docker-compose.yml - a configuração principal do Docker Compose para o projeto OpenSearch.
• opensearch.yml - configuração personalizada para contêineres OpenSearch.
• opensearch_dashbaords.yml - configuração personalizada para o contêiner OpenSearch Dashboards.
• internal_users.yml - autenticação e autorização de usuário personalizada para OpenSearch e OpenSearch Dashboards.

Gerando Certificados SSL/TLS

Nesta etapa, você gerará vários certificados TLS que serão usados para proteger sua implantação do OpenSearch. Você gerará os seguintes certificados:

• Certificados CA raiz: esses certificados serão usados para assinar outros certificados.
• Certificados de administrador: Esses certificados serão usados para obter direitos administrativos para executar todas as tarefas relacionadas ao plugin de segurança.
• Certificados do OpenSearch Dashboards: esses certificados serão usados para proteger os OpenSearch Dashboards e permitem que você acesse os OpenSearch Dashboards por meio de conexões HTTPS.
• Certificados de nó e cliente: esses certificados serão usados por nós e clientes dentro do cluster OpenSearch.

Para começar, execute o comando abaixo para criar novos diretórios que serão usados para certificados TLS de string.

mkdir -p certs/{ca,os-dashboards}

Crie uma nova variável de ambiente 'MYDN' que será usada para criar novos certificados TLS. Certifique-se de alterar os detalhes com suas informações.

export MYDN="/C=CA/ST=ONTARIO/L=TORONTO/O=HWDOMAIN"

Agora você está pronto para gerar certificados TLS para sua implantação do OpenSearch.

Gerar certificados CA

Gere uma chave privada para os certificados de CA raiz usando o seguinte.

openssl genrsa -out certs/ca/ca.key 2048

Agora gere um certificado CA raiz autoassinado por meio do comando abaixo. O valor do parâmetro '-subj' usa a variável de ambiente 'MYDN' que você criou na sessão atual.

openssl req -new -x509 -sha256 -days 1095 -subj "$MYDN/CN=CA" -key certs/ca/ca.key -out certs/ca/ca.pem

Com isso, você deve obter a chave privada da CA raiz 'ca.key' e o certificado da CA raiz 'ca.pem'. Você pode verificar os certificados CA gerados por meio do comando a seguir.

ls certs/ca/

Saída - Você deve obter a chave privada da CA 'ca.key' e o arquivo do certificado da CA 'ca.pem'.

Gerar certificados de administrador

Gere a nova chave privada do certificado de administrador 'admin-temp.key' e converta o certificado gerado para o algoritmo compatível com PKCS#12 (3DES). Com isso, sua chave privada de administrador deve ser 'admin.key'.

openssl genrsa -out certs/ca/admin-temp.key 2048
openssl pkcs8 -inform PEM -outform PEM -in certs/ca/admin-temp.key -topk8 -nocrypt -v1 PBE-SHA1-3DES -out certs/ca/admin.key

Em seguida, execute o comando abaixo para gerar o CSR (solicitação de assinatura de certificado) de administrador a partir da chave privada 'admin.key'. Seu CSR gerado agora deve ser o arquivo 'admin.csr'.

openssl req -new -subj "$MYDN/CN=ADMIN" -key certs/ca/admin.key -out certs/ca/admin.csr

Agora execute o comando abaixo para assinar o CSR do administrador com o certificado CA raiz e a chave privada. A saída do certificado administrativo é o arquivo 'admin.pem'.

openssl x509 -req -in certs/ca/admin.csr -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out certs/ca/admin.pem

Por último, verifique a lista de seus certificados através do seguinte comando.

ls certs/ca/

Saída - Você deverá ver os arquivos de certificado de administrador 'admin.pem' e a chave privada 'admin.key'.

Gerar certificados de painéis OpenSearch

Gere o novo certificado que será usado para os painéis OpenSearch.

Execute o seguinte comando para gerar a chave privada 'os-dashboards-temp.key' e converter o certificado gerado para o algoritmo compatível com PKCS#12 (3DES). Com isso, sua chave privada de administrador deve ser 'os-dashboards.key'.

openssl genrsa -out certs/os-dashboards/os-dashboards-temp.key 2048
openssl pkcs8 -inform PEM -outform PEM -in certs/os-dashboards/os-dashboards-temp.key -topk8 -nocrypt -v1 PBE-SHA1-3DES -out certs/os-dashboards/os-dashboards.key

Em seguida, execute o comando abaixo para gerar o CSR (Solicitação de assinatura de certificado) para os painéis OpenSearch. Seu CSR gerado agora deve ser o arquivo 'os-dashboards.csr'.

openssl req -new -subj "$MYDN/CN=os-dashboards" -key certs/os-dashboards/os-dashboards.key -out certs/os-dashboards/os-dashboards.csr

Agora execute o comando abaixo para assinar o CSR do OpenSearch Dashboards com o certificado CA raiz e a chave privada. A saída do certificado de administrador é o arquivo 'os-dashboards.pem'.

openssl x509 -req -in certs/os-dashboards/os-dashboards.csr -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out certs/os-dashboards/os-dashboards.pem

Por último, execute o seguinte comando para excluir o arquivo CSR do OpenSearch Dashboards e verificar a lista de seus certificados para os OpenSearch Dashboards.

rm certs/os-dashboards/os-dashboards-temp.key certs/os-dashboards/os-dashboards.csr
ls certs/os-dashboards/

Saída - Você deverá ver os arquivos de certificado do OpenSearch Dashboards 'os-dashboards.pem' e a chave privada 'os-dashboards.key'.

Gerar certificados para nós OpenSearch

Execute o comando a seguir para gerar certificados de nó. Com isso, você criará vários diretórios no diretório ‘certs’ e gerará certificados TLS para vários hosts.

for NODE_NAME in "os01" "os02" "os03"
do
    mkdir "certs/${NODE_NAME}"
    openssl genrsa -out "certs/$NODE_NAME/$NODE_NAME-temp.key" 2048
    openssl pkcs8 -inform PEM -outform PEM -in "certs/$NODE_NAME/$NODE_NAME-temp.key" -topk8 -nocrypt -v1 PBE-SHA1-3DES -out "certs/$NODE_NAME/$NODE_NAME.key"
    openssl req -new -subj "$MYDN/CN=$NODE_NAME" -key "certs/$NODE_NAME/$NODE_NAME.key" -out "certs/$NODE_NAME/$NODE_NAME.csr"
    openssl x509 -req -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:$NODE_NAME") -in "certs/$NODE_NAME/$NODE_NAME.csr" -CA certs/ca/ca.pem -CAkey certs/ca/ca.key -CAcreateserial -sha256 -out "certs/$NODE_NAME/$NODE_NAME.pem"
    rm "certs/$NODE_NAME/$NODE_NAME-temp.key" "certs/$NODE_NAME/$NODE_NAME.csr"
done

Verifique a lista de diretórios no diretório ‘certs’.

ls certs/

Saída - Você deve obter novos diretórios 'os01, os02, eos03.

Por fim, verifique a lista de certificados disponíveis nos diretórios os01, os02, eos03 através do comando abaixo.

ls certs/os01/
ls certs/os02/
ls certs/os03/

Saída - Em cada diretório, você deve obter dois certificados 'osX.key' e 'osX.pem'.

Por último, você deve alterar a propriedade do diretório 'certs' para '1000' através do comando abaixo. Isso permitirá que os contêineres do Docker acessem o diretório 'certs'.

sudo chown -R 1000:1000 certs/

Com os certificados TLS gerados, você gerará senhas com hash e definirá usuários do OpenSearch.

Configurando usuário

Nesta etapa, você gerará um hash de senha que será usado pelo OpenSearch e pelo OpenSearch Dashboards. Você gerará dois hashes de senha para dois usuários diferentes e, em seguida, modificará o arquivo de configuração 'internal_users.yml' e os usuários do OpenSearch.

Execute o seguinte comando docker para gerar um novo hash de senha. Isso executará um contêiner OpenSearch temporário e executará o script 'hash.sh' para gerar um hash de senha.

docker run -it --rm opensearchproject/opensearch sh -c "/usr/share/opensearch/plugins/opensearch-security/tools/hash.sh"

Agora insira sua senha e você deverá obter a senha com hash em seu terminal. Copie a senha hash gerada e execute novamente o comando para gerar outra senha hash.

Saída - Para senha com hash gerada para usuários do OpenSearch.

Em seguida, abra o arquivo 'internal_users.yml' usando o seguinte comando do editor nano.

nano internal_users.yml

Adicione as seguintes linhas ao arquivo e certifique-se de alterar a senha com hash com a senha gerada. Com isso, você definirá dois usuários para sua implantação do OpenSearch. o usuário 'admin' como administrador do OpenSearch e o usuário 'kibanaserver' que será usado para conectar-se ao OpenSearch Dashboards.

---
# This is the internal user database
# The hash value is a bcrypt hash and can be generated with plugin/tools/hash.sh
_meta:
  type: "internalusers"
  config_version: 2
# Define your internal users here
admin:
  hash: "$2y$12$y8UzXWoZKQc8GTgGsRz4g.CarjlC6sMPYN8XOD/NPQysRi2oq.Ws6"
  reserved: true
  backend_roles:
  - "admin"
  description: "Admin User"
kibanaserver:
  hash: "$2y$12$AKpGe4tM5nIWYFoM56yRue22pQh0jFfx59MUgUKnBu8qnyGeAm2Ze"
  reserved: true
  description: "OpenSearch Dashboards user"

Salve o arquivo e saia do editor quando terminar.

Configurar script docker-compose.yml

Nesta etapa, você criará um novo script Docker Compose para implantar OpenSearch e OpenSearch Dashboards. Você criará vários contêineres OpenSearch para configurar o cluster OpenSearch e configurará um contêiner OpenSearch Dashboards que será conectado ao cluster OpenSearch.

Abra o arquivo 'docker-compose.yml' usando o seguinte comando do editor nano.

nano docker-compose.yml

Adicione as seguintes linhas ao arquivo.

version: '3.7'
services:
  os01:
    restart: always
    image: opensearchproject/opensearch:latest
    environment:
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
      node.name: os01
      discovery.seed_hosts: os01,os02,os03
      cluster.initial_master_nodes: os01,os02,os03
      plugins.security.ssl.transport.pemkey_filepath: certificates/os01/os01.key # relative path
      plugins.security.ssl.transport.pemcert_filepath: certificates/os01/os01.pem
      plugins.security.ssl.http.pemkey_filepath: certificates/os01/os01.key
      plugins.security.ssl.http.pemcert_filepath: certificates/os01/os01.pem
      DISABLE_INSTALL_DEMO_CONFIG: "true"
      JAVA_HOME: /usr/share/opensearch/jdk
      bootstrap.memory_lock: "true" # along with the memlock settings below, disables swapping
      network.host: "0.0.0.0"
    ulimits: 
      memlock:
        soft: -1
        hard: -1
    volumes:
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"
      - "os-data1:/usr/share/opensearch/data"
      - "./certs:/usr/share/opensearch/config/certificates:ro"
    ports:
      - 9200:9200
      - 9600:9600 # required for Performance Analyzer
  
  os02:
    restart: always
    image: opensearchproject/opensearch:latest
    environment:
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
      node.name: os02
      discovery.seed_hosts: os01,os02,os03
      cluster.initial_master_nodes: os01,os02,os03
      plugins.security.ssl.transport.pemkey_filepath: certificates/os02/os02.key # relative path
      plugins.security.ssl.transport.pemcert_filepath: certificates/os02/os02.pem
      plugins.security.ssl.http.pemkey_filepath: certificates/os02/os02.key
      plugins.security.ssl.http.pemcert_filepath: certificates/os02/os02.pem
      DISABLE_INSTALL_DEMO_CONFIG: "true"
      JAVA_HOME: /usr/share/opensearch/jdk
      bootstrap.memory_lock: "true" # along with the memlock settings below, disables swapping
      network.host: "0.0.0.0"
    ulimits: 
      memlock:
        soft: -1
        hard: -1
    volumes:
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"
      - "os-data2:/usr/share/opensearch/data"
      - "./certs:/usr/share/opensearch/config/certificates:ro"
  
  os03:
    restart: always
    image: opensearchproject/opensearch:latest
    environment:
      OPENSEARCH_JAVA_OPTS: "-Xms1024m -Xmx1024m" # minimum and maximum Java heap size, recommend setting both to 50% of system RAM
      node.name: os03
      discovery.seed_hosts: os01,os02,os03
      cluster.initial_master_nodes: os01,os02,os03
      plugins.security.ssl.transport.pemkey_filepath: certificates/os03/os03.key # relative path
      plugins.security.ssl.transport.pemcert_filepath: certificates/os03/os03.pem
      plugins.security.ssl.http.pemkey_filepath: certificates/os03/os03.key
      plugins.security.ssl.http.pemcert_filepath: certificates/os03/os03.pem
      DISABLE_INSTALL_DEMO_CONFIG: "true"
      JAVA_HOME: /usr/share/opensearch/jdk
      bootstrap.memory_lock: "true" # along with the memlock settings below, disables swapping
      network.host: "0.0.0.0"
    ulimits: 
      memlock:
        soft: -1
        hard: -1
    volumes:
      - "./opensearch.yml:/usr/share/opensearch/config/opensearch.yml"
      - "./internal_users.yml:/usr/share/opensearch/config/opensearch-security/internal_users.yml"
      - "os-data3:/usr/share/opensearch/data"
      - "./certs:/usr/share/opensearch/config/certificates:ro"
  
  osdashboards:
    restart: always
    image: opensearchproject/opensearch-dashboards:latest
    ports:
      - 5601:5601
    volumes:
      - "./certs:/usr/share/opensearch-dashboards/config/certificates:ro"
      - "./opensearch_dashboards.yml:/usr/share/opensearch-dashboards/config/opensearch_dashboards.yml"
    environment:
      OPENSEARCH_HOSTS: '["https://os01:9200","https://os02:9200","https://os03:9200"]' # must be a string with no spaces when specified as an environment variable
      DISABLE_INSTALL_DEMO_CONFIG: "true"
volumes:
  os-data1:
  os-data2:
  os-data3:

Salve e saia do arquivo 'docker-compose.yml' quando terminar.

Com isso, você criará 4 contêineres/serviços para as implantações do OpenSearch. Abaixo estão informações detalhadas sobre cada contêiner.

• 3 contêineres OpenSearch os01, os02 e os03 - serão usados para criar o cluster OpenSearch. Esses contêineres são baseados na imagem 'opensearchproject/opensearch:latest' e nas mesmas configurações 'opensearch.yml' e 'internal_users.yml'.
• Um contêiner 'osdashboards' do OpenSearch Dashboards é baseado na imagem 'opensearchproject/opensearch-dashboards:latest' e está conectado a três hosts do OpenSearch os01, os02 e os03. Além disso, você desabilitará a configuração de demonstração no contêiner OpenSearch Dashboards.
• Todos os contêineres OpenSearch e OpenSearch Dashboards serão protegidos por meio de certificados TLS personalizados que estão disponíveis no diretório 'certs'.
• O contêiner OpenSearch exporá duas portas 9200 e 9600, e o contêiner OpenSearch Dashboards exporá a porta 5601.

Configurar OpenSearch e painéis OpenSearch

Nesta etapa, você criará uma nova configuração para OpenSearch 'opensearch.yml' e OpenSearch Dashboards 'opensearch_dashbaords.yml'. No final, você deve garantir que todas as configurações e certificados necessários estejam disponíveis no diretório do projeto OpenSearch.

Abra o arquivo de configuração do OpenSearch 'opensearch.yml' usando o seguinte comando do editor nano.

sudo nano opensearch.yml

Adicione as seguintes linhas ao arquivo. Certifique-se de alterar o caminho dos certificados CA e DN para certificados de administrador e de nó. Com isso, você configurará um cluster OpenSearch com o nome 'os-cluster'.

cluster.name: os-cluster
network.host: 0.0.0.0
bootstrap.memory_lock: "true" # along with the memlock settings below, disables swapping
plugins.security.allow_unsafe_democertificates: true
plugins.security.ssl.http.enabled: true
plugins.security.ssl.http.pemtrustedcas_filepath: certificates/ca/ca.pem
plugins.security.ssl.transport.enabled: true
plugins.security.ssl.transport.pemtrustedcas_filepath: certificates/ca/ca.pem
plugins.security.ssl.transport.enforce_hostname_verification: false
plugins.security.authcz.admin_dn:
  - 'CN=ADMIN,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
plugins.security.nodes_dn:
  - 'CN=os00,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os01,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os02,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os03,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os04,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os05,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os06,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
  - 'CN=os07,O=HWDOMAIN,L=TORONTO,ST=ONTARIO,C=CA'
plugins.security.audit.type: internal_opensearch
plugins.security.enable_snapshot_restore_privilege: true
plugins.security.check_snapshot_restore_write_privileges: true
plugins.security.restapi.roles_enabled: ["all_access", "security_rest_api_access"]
cluster.routing.allocation.disk.threshold_enabled: false
opendistro_security.audit.config.disabled_rest_categories: NONE
opendistro_security.audit.config.disabled_transport_categories: NONE

Salve o arquivo 'opensearch.yml' e saia do editor quando terminar.

Em seguida, abra o arquivo de configuração do OpenSearch Dashboards 'opensearch_dashboards.yml' usando o comando do editor nano abaixo.

nano opensearch_dashboards.yml

Adicione as seguintes linhas ao arquivo. Certifique-se de alterar o nome de usuário e a senha dos painéis OpenSearch com os detalhes do usuário 'kibanaserver' no arquivo 'internal_users.yml'.

server.name: os_dashboards
server.host: "0.0.0.0"
opensearch.username: kibanaserver
opensearch.password: password
opensearch.requestHeadersWhitelist: [authorization, securitytenant]
opensearch_security.multitenancy.enabled: true
opensearch_security.multitenancy.tenants.preferred: [Private, Global]
opensearch_security.readonly_mode.roles: [kibana_read_only]
# Use this setting if you are running opensearch-dashboards without https
opensearch_security.cookie.secure: false
# Encrypt traffic between the browser and OpenSearch-Dashboards
server.ssl.enabled: true
server.ssl.certificate: "/usr/share/opensearch-dashboards/config/certificates/os-dashboards/os-dashboards.pem"
server.ssl.key: "/usr/share/opensearch-dashboards/config/certificates/os-dashboards/os-dashboards.key"
# Encrypt traffic between OpenSearch-Dashboards and Opensearch
opensearch.ssl.certificateAuthorities: ["/usr/share/opensearch-dashboards/config/certificates/ca/ca.pem"]
opensearch.ssl.verificationMode: full

Salve e saia do arquivo quando terminar.

Por último, execute o comando apt abaixo para instalar o pacote tree e verificar a lista de arquivos e diretórios de sua implantação OpenSearch.

sudo apt install tree
tree .

Você deve receber uma saída como esta.

Com isso, toda a preparação para implantação do OpenSearch via Docker está finalizada. Você está pronto para implantar o OpenSearch via Docker e Docker Compose.

Implantando OpenSearch Cluster e OpenSearch Dashboards

Antes de começar, verifique se você está no diretório do projeto OpenSearch 'opensearch-project'. Em seguida, execute o seguinte comando 'docker compose' para criar e iniciar a implantação do OpenSearch.

docker compose up -d

Você deverá receber uma saída como esta: Existem três contêineres OpenSearch os01, os02 e os03 criados e iniciados. Além disso, o contêiner do OpenSearch Dashboards 'osdashboards' é criado e iniciado.

Verifique a lista de serviços/contêineres em execução em seu projeto OpenSearch por meio do comando a seguir.

docker compose ps

Se você vir que 'STATUS' é 'Up', então o contêiner/serviço está em execução. Na seção 'PORTAS' você deverá ver as portas expostas por contêiner para a máquina host.

Com o cluster OpenSearch em execução, agora você deve aplicar a nova configuração de usuário criada por meio do arquivo 'internal_users.yml'. Para conseguir isso, você pode executar o seguinte comando 'docker'. Além disso, espere cerca de 30-60 segundos antes de executar este comando para garantir que o cluster OpenSearch esteja em execução.

O comando a seguir executará o script bash 'securityadmin.sh' no contêiner/serviço 'os01' e aplicará novos usuários em seu cluster OpenSearch.

docker compose exec os01 bash -c "chmod +x plugins/opensearch-security/tools/securityadmin.sh && bash plugins/opensearch-security/tools/securityadmin.sh -cd config/opensearch-security -icl -nhnv -cacert config/certificates/ca/ca.pem -cert config/certificates/ca/admin.pem -key config/certificates/ca/admin.key -h localhost"

Saída :

Em seguida, execute o seguinte comando para garantir que o contêiner esteja em execução. Em seguida, você pode verificar a lista de portas abertas no host Docker por meio do comando ss abaixo.

docker compose ps
ss -tulpn

Saída - as portas 9200 e 9600 são usadas pelo cluster OpenSearch e a porta 5601 é usada pelos OpenSearch Dashboards.

Por último, você pode verificar a autenticação no cluster OpenSearch por meio do nome de usuário e da senha que você criou no arquivo 'internal_users.yml'.

Faça uma autenticação como usuário administrador no cluster OpenSearch.

curl https://192.168.5.100:9200 -u admin:password -k

Saída – A autenticação foi bem-sucedida e você deverá ver detalhes do software OpenSearch que está usando atualmente em seu cluster.

Faça uma autenticação como usuário kibanaserver no cluster OpenSearch.

curl https://192.168.5.100:9200 -u kibanaserver:password -k

Saída – A autenticação foi bem-sucedida e você deverá ver detalhes do software OpenSearch que está usando atualmente em seu cluster.

Com isso, você implantou o cluster OpenSearch e os painéis OpenSearch por meio do Docker e do Docker Compose. Na próxima etapa, você acessará a implantação do OpenSearch Dashboards e verificará a conexão entre o OpenSearch Dashboards e o cluster do OpenSearch.

Além disso, quando você tiver um erro na implantação do OpenSearch, poderá verificar os logs de cada contêiner por meio do comando 'docker compose' abaixo.

Uso básico 'docker compose' para verificação de logs.

docker compose logs
docker compose logs SERVICE

Verificando logs para contêineres/serviços específicos por meio do comando 'docker compose'.

docker compose logs osdashboards
docker compose logs os01
docker compose logs os02
docker compose logs os03

Acessando painéis do OpenSearch

Abra seu navegador da web e visite o endereço IP do seu servidor seguido pela porta do OpenSearch Dashboards '5601' (ou seja: https://192.168.5.100:5601/). Você deve obter a página de login do OpenSearch Dashboards.

Insira o usuário 'kibanaserver' e a senha e clique em 'Fazer login'.

Quando tiver sucesso, você deverá obter a seguinte página. Clique em 'Explorar por conta própria' e você deverá ver a página inicial do OpenSearch Dashboard.

Com isso, você tem o OpenSearch Dashboards em execução e a autenticação habilitada. Além disso, os painéis do OpenSearch estão sendo executados em conexões HTTPS seguras por meio de certificados SSL/TLS que você gerou.

Em seguida, verifique a conexão entre o OpenSearch Dashboards e o cluster OpenSearch por meio da API OpenSearch.

Clique no menu esquerdo, vá para a seção Gerenciamento e clique em 'Ferramentas de Desenvolvimento'.

Agora insira a consulta 'GET /' no console e clique no botão play. Quando for bem-sucedido, você deverá ver a saída no lado direito com informações detalhadas sobre o seu servidor OpenSearch. Além disso, você pode ver no canto superior direito o código HTTP '200 - OK' que confirma que a consulta foi executada sem erros.

Insira outra consulta 'GET _cat/nodes?format=json&filter_path=ip,name' para verificar os nós OpenSearch que estão disponíveis no cluster OpenSearch. Você deverá ver três nós diferentes no cluster OpenSearch, os01 com endereço IP 172.23.0.5, os02 com endereço IP '172.23. 0.3' e os3 com endereço IP '172.23.0.2'.

Isso confirma que os painéis OpenSearch estão conectados ao cluster OpenSearch.

Conclusão

Neste tutorial, você instalou o OpenSearch via Docker e Docker Compose no servidor Ubuntu 22.04. Você criou o OpenSearch Cluster com três contêineres diferentes no Docker. Você também protegeu o OpenSearch com certificados TLS, habilitou autenticação e autorização e configurou usuários no OpenSearch. Além disso, você também configurou e otimizou um servidor Ubuntu Linux para implantar o OpenSearch.

Você também instalou os OpenSearch Dashboards via Docker e Docker Compose. Em seguida, você também conectou o contêiner OpenSearch Dashboards ao OpenSearch Cluster.

Com esta configuração, agora você pode explorar mais sobre o OpenSearch, adicionar alguma integração ao seu OpenSearch, configurar autenticação adicional e muito mais. Você aprende mais sobre o OpenSearch na documentação oficial do OpenSearch.