One place for hosting & domains

      Instalar

      Como Instalar Elasticsearch, Logstash e Kibana (Elastic Stack) no Ubuntu 18.04


      O autor selecionou o Internet Archive para receber uma doação como parte do programa Write for DOnations

      Introdução

      O Elastic Stack — anteriormente conhecido como ELK Stack — é uma coleção de software open-source produzido pela Elastic que lhe permite pesquisar, analisar e visualizar logs gerados a partir de qualquer fonte, em qualquer formato, em uma prática conhecida como centralização de logs. A centralização de logs pode ser muito útil ao tentar identificar problemas com seus servidores ou aplicativos, pois permite que você pesquise todos os seus logs em um único local. Ela é útil também porque permite identificar problemas que envolvem vários servidores, correlacionando seus logs durante um período de tempo específico.

      O Elastic Stack possui quatro componentes principais:

      • Elasticsearch: um mecanismo de pesquisa RESTful distribuído que armazena todos os dados coletados.

      • Logstash: o componente de processamento de dados do Elastic Stack que envia dados de entrada para o Elasticsearch.

      • Kibana: uma interface web para a pesquisa e a visualização de logs.

      • Beats: carregadores de dados leves e de propósito único que podem enviar dados de centenas ou milhares de máquinas para o Logstash ou para o Elasticsearch.

      Neste tutorial você irá instalar o Elastic Stack em um servidor Ubuntu 18.04. Você irá aprender como instalar todos os componentes do Elastic Stack — incluindo o Filebeat, um Beat usado para encaminhar e centralizar logs e arquivos — e configurá-los para reunir e visualizar os logs do sistema. Além disso, como o Kibana normalmente está disponível apenas no localhost, usaremos o Nginx para fazer proxy dele, de modo que ele seja acessível em um navegador web. Instalaremos todos esses componentes em um único servidor, o qual nos referiremos como nosso servidor Elastic Stack.

      Nota: Ao instalar o Elastic Stack, você deve usar a mesma versão em toda a pilha ou stack. Neste tutorial vamos instalar as versões mais recentes de toda a stack, que são, no momento desta publicação, Elasticsearch 6.4.3, Kibana 6.4.3, Logstash 6.4.3 e Filebeat 6.4.3.

      Pré-requisitos

      Para completar este tutorial, você irá precisar do seguinte:

      • Um servidor Ubuntu configurado seguindo nosso Guia de Configuração Inicial de servidor com Ubuntu 18.04, incluindo um usuário não-root com privilégios sudo e um firewall configurado com ufw. A quantidade de CPU, RAM e armazenamento que o seu servidor Elastic Stack exigirá depende do volume de logs que você pretende reunir. Para este tutorial, usaremos um VPS com as seguintes especificações para o nosso servidor Elastic Stack:

        • SO: Ubuntu 18.04
        • RAM: 4GB
        • CPU: 2
      • Java 8 — que é exigido pelo Elasticsearch e pelo Logstash — instalado em seu servidor. Observe que o Java 9 não é suportado. Para istalar isso, siga a seção “Installing the Oracle JDK” do nosso guia sobre como instalar o Java 8 no Ubuntu 18.04.

      • Nginx instalado em seu servidor, que vamos configurar mais tarde neste guia como um proxy reverso para o Kibana. Siga nosso guia sobre Como Instalar o Nginx no Ubuntu 18.04 para configurar isso.

      Além disso, como o Elastic Stack é usado para acessar informações valiosas sobre seu servidor, as quais você não deseja que usuários não autorizados acessem, é importante manter seu servidor seguro instalando um certificado TLS/SSL. Isso é opcional mas é fortemente recomendado.

      No entanto, como você acabará fazendo alterações no bloco do servidor Nginx ao longo deste guia, provavelmente faria mais sentido para você concluir o guia Como Proteger o Nginx com o Let’s Encrypt no Ubuntu 18.04 no final do segundo passo deste tutorial. Com isso em mente, se você planeja configurar o Let’s Encrypt no seu servidor, você precisará do seguinte, antes de fazer isso:

      • Um domínio completamente qualificado (FQDN). Este tutorial irá utilizar example.com durante todo o processo. Você pode comprar um nome de domínio em Namecheap, obter um gratuitamente em Freenom, ou utilizar o registrador de domínio de sua escolha.

      • Ambos os registros DNS a seguir configurados para o seu servidor. Você pode seguir esta introdução ao DigitalOcean DNS para detalhes sobre como adicioná-los.

        • Um registro A com example.com apontando para o endereço IP público do seu servidor.
        • Um registro A com www.example.com apontando para o endereço IP público do seu servidor.

      Passo 1 — Instalando e Configurando o Elasticsearch

      Os componentes do Elastic Stack não estão disponíveis nos repositórios de pacotes padrão do Ubuntu. Eles podem, no entanto, ser instalados com o APT após adicionar a lista de origens de pacotes da Elastic.

      Todos os pacotes do Elastic Stack são assinados com a chave de assinatura do Elasticsearch para proteger seu sistema contra falsificação de pacotes. Os pacotes que foram autenticados usando a chave serão considerados confiáveis pelo seu gerenciador de pacotes. Nesta etapa, você importará a chave GPG pública do Elasticsearch e adicionará a lista de origens de pacotes da Elastic para instalar o Elasticsearch.

      Para começar, execute o seguinte comando para importar a chave GPG pública do Elasticsearch para o APT:

      • wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

      Em seguida, adicione a lista de origens da Elastic ao diretório sources.list.d, onde o APT irá procurar por novas origens:

      • echo "deb https://artifacts.elastic.co/packages/6.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-6.x.list

      Em seguida, atualize suas listas de pacotes para que o APT leia a nova origem da Elastic:

      Em seguida, instale o Elasticsearch com este comando:

      • sudo apt install elasticsearch

      Quando o Elasticsearch terminar a instalação, use seu editor de texto preferido para editar o arquivo de configuração principal do Elasticsearch, elasticsearch.yml. Aqui, usaremos o nano:

      • sudo nano /etc/elasticsearch/elasticsearch.yml

      Nota: O arquivo de configuração do Elasticsearch está no formato YAML, o que significa que a identação é muito importante! Certifique-se de não adicionar espaços extras ao editar esse arquivo.

      O Elasticsearch escuta o tráfego vindo de qualquer lugar na porta 9200. Você vai querer restringir o acesso externo à sua instância do Elasticsearch para impedir que pessoas de fora leiam seus dados ou desliguem o cluster do Elasticsearch por meio da API REST. Encontre a linha que especifica network.host, descomente-a e substitua seu valor por localhost para que fique assim:

      /etc/elasticsearch/elasticsearch.yml

      . . .
      network.host: localhost
      . . .
      

      Salve e feche o elasticsearch.yml pressionando CTRL+X, seguido de Y e depoisENTER se você estiver usando o nano. Em seguida, inicie o serviço Elasticsearch com o systemctl:

      • sudo systemctl start elasticsearch

      Depois, execute o seguinte comando para permitir que o Elasticsearch seja iniciado toda vez que o servidor for inicializado:

      • sudo systemctl enable elasticsearch

      Você pode testar se o serviço do Elasticsearch está sendo executado enviando uma solicitação HTTP:

      • curl -X GET "localhost:9200"

      Você verá uma resposta mostrando algumas informações básicas sobre o seu nó local, semelhante a esta:

      Output

      { "name" : "ZlJ0k2h", "cluster_name" : "elasticsearch", "cluster_uuid" : "beJf9oPSTbecP7_i8pRVCw", "version" : { "number" : "6.4.2", "build_flavor" : "default", "build_type" : "deb", "build_hash" : "04711c2", "build_date" : "2018-09-26T13:34:09.098244Z", "build_snapshot" : false, "lucene_version" : "7.4.0", "minimum_wire_compatibility_version" : "5.6.0", "minimum_index_compatibility_version" : "5.0.0" }, "tagline" : "You Know, for Search" }

      Agora que o Elasticsearch está instalado e funcionando, vamos instalar o Kibana, o próximo componente do Elastic Stack.

      Passo 2 — Instalando e Configurando o Painel do Kibana

      De acordo com a documentação oficial, você deve instalar o Kibana somente após instalar o Elasticsearch. A instalação nesta ordem garante que os componentes dos quais cada produto depende estão corretamente posicionados.

      Como você já adicionou a origem de pacotes do Elastic no passo anterior, você pode simplesmente instalar os componentes restantes do Elastic Stack usando o apt:

      Em seguida, ative e inicie o serviço Kibana:

      • sudo systemctl enable kibana
      • sudo systemctl start kibana

      Como o Kibana está configurado para escutar somente no localhost, devemos configurar um proxy reverso para permitir acesso externo a ele. Utilizaremos o Nginx para esse propósito, que já deve estar instalado no seu servidor.

      Primeiro, use o comando openssl para criar um usuário administrativo do Kibana que será usado para acessar a interface web do mesmo. Como exemplo, nomearemos essa conta como kibanaadmin, mas para garantir maior segurança, recomendamos que você escolha um nome que não seja óbvio para seu usuário e que seja difícil de adivinhar.

      O comando a seguir criará o usuário e a senha do usuário administrativo do Kibana e os armazenará no arquivo htpasswd.users. Você irá configurar o Nginx para requerer este nome de usuário e senha e ler este arquivo momentaneamente:

      • echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

      Digite e confirme uma senha no prompt. Lembre-se ou anote este login, pois você precisará dele para acessar a interface web do Kibana.

      Em seguida, criaremos um arquivo de bloco do servidor Nginx. Como exemplo, vamos nos referir a este arquivo como example.com, embora você possa achar útil dar um nome mais descritivo ao seu. Por exemplo, se você tiver um FQDN e registros DNS configurados para este servidor, poderá nomear esse arquivo após seu FQDN:

      • sudo nano /etc/nginx/sites-available/example.com

      Adicione o seguinte bloco de código ao arquivo, certificando-se de atualizar example.com para corresponder ao FQDN do seu servidor ou ao seu endereço IP público. Este código configura o Nginx para direcionar o tráfego HTTP do seu servidor para o aplicativo Kibana, que está escutando em localhost:5601. Além disso, configura o Nginx para ler o arquivo htpasswd.users e requerer autenticação básica.

      Observe que, se você seguiu o o tutorial de pré-requisitos do Nginx até o final, você já deve ter criado esse arquivo e preenchido com algum conteúdo. Nesse caso, exclua todo o conteúdo existente no arquivo antes de adicionar o seguinte:

      /etc/nginx/sites-available/example.com

      
      server {
          listen 80;
      
          server_name example.com;
      
          auth_basic "Restricted Access";
          auth_basic_user_file /etc/nginx/htpasswd.users;
      
          location / {
              proxy_pass http://localhost:5601;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      }
      

      Quando terminar, salve e feche o arquivo.

      Em seguida, ative a nova configuração criando um link simbólico para o diretório sites-enabled. Se você já criou um arquivo de bloco do servidor com o mesmo nome no pré-requisito do Nginx, não será necessário executar este comando:

      • sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com

      Em seguida, verifique a configuração para erros de sintaxe:

      Se algum erro for relatado em sua saída, volte e verifique se o conteúdo que você colocou no seu arquivo de configuração foi adicionado corretamente. Uma vez que você veja syntax is ok na saída, vá em frente e reinicie o serviço Nginx:

      • sudo systemctl restart nginx

      Se você seguiu o guia de configuração inicial do servidor, você deverá ter um firewall UFW ativado. Para permitir conexões ao Nginx, podemos ajustar as regras digitando:

      • sudo ufw allow 'Nginx Full'

      Nota: Se você seguiu o tutorial de pré-requisitos do Nginx, você pode ter criado uma regra UFW permitindo o perfil Nginx HTTP através do firewall. Como o perfil Nginx Full permite o tráfego HTTP e HTTPS através do firewall, você pode excluir com segurança a regra criada no tutorial de pré-requisitos. Faça isso com o seguinte comando:

      • sudo ufw delete allow 'Nginx HTTP'

      O Kibana agora pode ser acessado pelo seu FQDN ou pelo endereço IP público do seu servidor Elastic Stack. Você pode verificar a página de status do servidor Kibana, navegando até o seguinte endereço e digitando suas credenciais de login quando solicitado:

      • http://ip_do_seu_servidor/status

      Essa página de status exibe informações sobre o uso de recursos do servidor e lista os plug-ins instalados.

      Note: Conforme mencionado na seção de Pré-requisitos, é recomendável ativar o SSL/TLS em seu servidor. Você pode seguir este tutorial agora para obter um certificado SSL grátis para o Nginx no Ubuntu 18.04. Depois de obter seus certificados SSL/TLS, você pode voltar e concluir este tutorial.

      Agora que o painel do Kibana está configurado, vamos instalar o próximo componente: Logstash.

      Passo 3 — Instalando e Configurando o Logstash

      Embora seja possível que o Beats envie dados diretamente para o banco de dados do Elasticsearch, recomendamos o uso do Logstash para processar os dados. Isso permitirá coletar dados de diferentes origens, transformá-los em um formato comum e exportá-los para outro banco de dados.

      Instale o Logstash com este comando:

      • sudo apt install logstash

      Depois de instalar o Logstash, você pode continuar a configurá-lo. Os arquivos de configuração do Logstash são escritos no formato JSON e residem no diretório /etc/logstash/conf.d. Ao configurá-lo, é útil pensar no Logstash como um pipeline que coleta dados em uma extremidade, os processa de uma forma ou de outra e os envia para o destino (nesse caso, o destino é o Elasticsearch). Um pipeline do Logstash tem dois elementos obrigatórios, input e output, e um elemento opcional, filter. Os plugins de input ou de entrada consomem dados de uma fonte, os plug-ins filter ou de filtro processam os dados, e os plugins de output ou de saída gravam os dados em um destino.

      Crie um arquivo de configuração chamado 02-beats-input.conf onde você irá configurar sua entrada para o Filebeat:

      • sudo nano /etc/logstash/conf.d/02-beats-input.conf

      Insira a seguinte configuração de input. Isto especifica uma entrada beats que irá escutar na porta TCP 5044.

      /etc/logstash/conf.d/02-beats-input.conf

      
      input {
        beats {
          port => 5044
        }
      }
      

      Salve e feche o arquivo. Em seguida, crie um arquivo de configuração chamado 10-syslog-filter.conf, onde adicionaremos um filtro para logs do sistema, também conhecido como syslogs:

      • sudo nano /etc/logstash/conf.d/10-syslog-filter.conf

      Insira a seguinte configuração do filtro syslog. Este exemplo de configuração de logs do sistema foi retirado da documentação oficial do Elastic. Esse filtro é usado para analisar os logs de entrada do sistema para torná-los estruturados e utilizáveis pelos painéis predefinidos do Kibana:

      /etc/logstash/conf.d/10-syslog-filter.conf

      
      filter {
        if [fileset][module] == "system" {
          if [fileset][name] == "auth" {
            grok {
              match => { "message" => ["%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:[%{POSINT:[system][auth][pid]}])?: %{DATA:[system][auth][ssh][event]} %{DATA:[system][auth][ssh][method]} for (invalid user )?%{DATA:[system][auth][user]} from %{IPORHOST:[system][auth][ssh][ip]} port %{NUMBER:[system][auth][ssh][port]} ssh2(: %{GREEDYDATA:[system][auth][ssh][signature]})?",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:[%{POSINT:[system][auth][pid]}])?: %{DATA:[system][auth][ssh][event]} user %{DATA:[system][auth][user]} from %{IPORHOST:[system][auth][ssh][ip]}",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sshd(?:[%{POSINT:[system][auth][pid]}])?: Did not receive identification string from %{IPORHOST:[system][auth][ssh][dropped_ip]}",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} sudo(?:[%{POSINT:[system][auth][pid]}])?: s*%{DATA:[system][auth][user]} 🙁 %{DATA:[system][auth][sudo][error]} ;)? TTY=%{DATA:[system][auth][sudo][tty]} ; PWD=%{DATA:[system][auth][sudo][pwd]} ; USER=%{DATA:[system][auth][sudo][user]} ; COMMAND=%{GREEDYDATA:[system][auth][sudo][command]}",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} groupadd(?:[%{POSINT:[system][auth][pid]}])?: new group: name=%{DATA:system.auth.groupadd.name}, GID=%{NUMBER:system.auth.groupadd.gid}",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} useradd(?:[%{POSINT:[system][auth][pid]}])?: new user: name=%{DATA:[system][auth][user][add][name]}, UID=%{NUMBER:[system][auth][user][add][uid]}, GID=%{NUMBER:[system][auth][user][add][gid]}, home=%{DATA:[system][auth][user][add][home]}, shell=%{DATA:[system][auth][user][add][shell]}$",
                        "%{SYSLOGTIMESTAMP:[system][auth][timestamp]} %{SYSLOGHOST:[system][auth][hostname]} %{DATA:[system][auth][program]}(?:[%{POSINT:[system][auth][pid]}])?: %{GREEDYMULTILINE:[system][auth][message]}"] }
              pattern_definitions => {
                "GREEDYMULTILINE"=> "(.|n)*"
              }
              remove_field => "message"
            }
            date {
              match => [ "[system][auth][timestamp]", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
            }
            geoip {
              source => "[system][auth][ssh][ip]"
              target => "[system][auth][ssh][geoip]"
            }
          }
          else if [fileset][name] == "syslog" {
            grok {
              match => { "message" => ["%{SYSLOGTIMESTAMP:[system][syslog][timestamp]} %{SYSLOGHOST:[system][syslog][hostname]} %{DATA:[system][syslog][program]}(?:[%{POSINT:[system][syslog][pid]}])?: %{GREEDYMULTILINE:[system][syslog][message]}"] }
              pattern_definitions => { "GREEDYMULTILINE" => "(.|n)*" }
              remove_field => "message"
            }
            date {
              match => [ "[system][syslog][timestamp]", "MMM  d HH:mm:ss", "MMM dd HH:mm:ss" ]
            }
          }
        }
      }
      

      Salve e feche o arquivo quando terminar.

      Por fim, crie um arquivo de configuração chamado 30-elasticsearch-output.conf:

      • sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

      Insira a seguinte configuração para output. Essencialmente, esta saída configura o Logstash para armazenar os dados do Beats no Elasticsearch, que está sendo executado em localhost:9200, em um índice ou index nomeado após o uso do Beat. O Beat usado neste tutorial é o Filebeat:

      /etc/logstash/conf.d/30-elasticsearch-output.conf

      
      output {
        elasticsearch {
          hosts => ["localhost:9200"]
          manage_template => false
          index => "%{[@metadata][beat]}-%{[@metadata][version]}-%{+YYYY.MM.dd}"
        }
      }
      

      Salve e feche o arquivo.

      Se você quiser adicionar filtros para outros aplicativos que usam a entrada Filebeat, certifique-se de nomear os arquivos de forma que eles sejam classificados entre a configuração de entrada e a de saída, o que significa que os nomes dos arquivos devem começar com um número de dois dígitos entre 02 e 30.

      Teste sua configuração do Logstash com este comando:

      • sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

      Se não houver erros de sintaxe, sua saída exibirá Configuration OK após alguns segundos. Se você não vir isso na sua saída, verifique se há erros que apareçam na sua saída e atualize sua configuração para corrigi-los.

      Se seu teste de configuração for bem-sucedido, inicie e ative o Logstash para colocar as mudanças de configuração em vigor:

      • sudo systemctl start logstash
      • sudo systemctl enable logstash

      Agora que o Logstash está sendo executado corretamente e está totalmente configurado, vamos instalar o Filebeat.

      Passo 4 — Instalando e Configurando o Filebeat

      O Elastic Stack usa vários carregadores de dados leves chamados Beats para coletar dados de várias fontes e transportá-los para o Logstash ou para o Elasticsearch. Aqui estão os Beats que estão atualmente disponíveis na Elastic:

      • Filebeat: coleta e envia arquivos de log.

      • Metricbeat: coleta métricas de seus sistemas e serviços.

      • Packetbeat: coleta e analisa dados da rede.

      • Winlogbeat: coleta logs de eventos do Windows.

      • Auditbeat: coleta dados da estrutura de auditoria do Linux e monitora a integridade dos arquivos.

      • Heartbeat: monitora serviços para verificar sua disponibilidade com sondagem ativa.

      Neste tutorial, usaremos o Filebeat para encaminhar logs locais para o nosso Elastic Stack.

      Instale o Filebeat usando o apt:

      • sudo apt install filebeat

      Em seguida, configure o Filebeat para se conectar ao Logstash. Aqui, vamos modificar o arquivo de configuração de exemplo que vem com o Filebeat.

      Abra o arquivo de configuração do Filebeat:

      • sudo nano /etc/filebeat/filebeat.yml

      Nota: Assim como no Elasticsearch, o arquivo de configuração do Filebeat está no formato YAML. Isso significa que a identação adequada é crucial, portanto, certifique-se de usar o mesmo número de espaços indicados nestas instruções.

      O Filebeat suporta várias saídas, mas normalmente você só envia eventos diretamente para o Elasticsearch ou para o Logstash para processamento adicional. Neste tutorial, usaremos o Logstash para executar processamento adicional nos dados coletados pelo Filebeat. O Filebeat não precisará enviar nenhum dado diretamente para o Elasticsearch, então vamos desativar essa saída. Para fazer isso, encontre a seção output.elasticsearch e comente as seguintes linhas, precedendo-as com um #:

      /etc/filebeat/filebeat.yml

      
      ...
      #output.elasticsearch:
        # Array of hosts to connect to.
        #hosts: ["localhost:9200"]
      ...
      

      Em seguida, configure a seção output.logstash. Descomente as linhas output.logstash: e hosts: ["localhost:5044"] removendo o #. Isto irá configurar o Filebeat para se conectar ao Logstash no seu servidor Elastic Stack na porta 5044, a porta para a qual especificamos uma entrada do Logstash anteriormente:

      /etc/filebeat/filebeat.yml

      
      output.logstash:
        # The Logstash hosts
        hosts: ["localhost:5044"]
      

      Salve e feche o arquivo.

      A funcionalidade do Filebeat pode ser estendida com os módulos do Filebeat. Neste tutorial vamos usar o módulo system, que coleta e analisa logs criados pelo serviço de logs do sistema em distribuições comuns do Linux.

      Vamos habilitar isso:

      • sudo filebeat modules enable system

      Você pode ver uma lista de módulos ativados e desativados executando:

      • sudo filebeat modules list

      Você verá uma lista semelhante à seguinte:

      Output

      Enabled: system Disabled: apache2 auditd elasticsearch icinga iis kafka kibana logstash mongodb mysql nginx osquery postgresql redis traefik

      Por padrão, o Filebeat é configurado para usar os caminhos padrão para os logs de syslog e de autorização. No caso deste tutorial, você não precisa alterar nada na configuração. Você pode ver os parâmetros do módulo no arquivo de configuração /etc/filebeat/modules.d/system.yml.

      Em seguida, carregue o modelo de index do Elasticsearch. Um index do Elasticsearch é uma coleção de documentos que possuem características semelhantes. Os index são identificados com um nome, que é usado para se referir ao index ao executar várias operações dentro dele. O modelo de index será aplicado automaticamente quando um novo index for criado.

      Para carregar o modelo, use o seguinte comando:

      • sudo filebeat setup --template -E output.logstash.enabled=false -E 'output.elasticsearch.hosts=["localhost:9200"]'

      Output

      Loaded index template

      O Filebeat vem com painéis de amostra do Kibana que lhe permitem visualizar dados do Filebeat no Kibana. Antes de poder usar os painéis, você precisa criar o padrão de index e carregar os painéis no Kibana.

      À medida que os painéis são carregados, o Filebeat se conecta ao Elasticsearch para verificar as informações da versão. Para carregar painéis quando o Logstash está ativado, é necessário desativar a saída do Logstash e ativar a saída do Elasticsearch:

      • sudo filebeat setup -e -E output.logstash.enabled=false -E output.elasticsearch.hosts=['localhost:9200'] -E setup.kibana.host=localhost:5601

      Você verá uma saída que se parece com isto:

      Output

      2018-09-10T08:39:15.844Z INFO instance/beat.go:273 Setup Beat: filebeat; Version: 6.4.2 2018-09-10T08:39:15.845Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.845Z INFO pipeline/module.go:98 Beat name: elk 2018-09-10T08:39:15.845Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.849Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:15.856Z INFO template/load.go:129 Template already exists and will not be overwritten. Loaded index template Loading dashboards (Kibana must be running and reachable) 2018-09-10T08:39:15.857Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:15.865Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:15.865Z INFO kibana/client.go:113 Kibana url: http://localhost:5601 2018-09-10T08:39:45.357Z INFO instance/beat.go:659 Kibana dashboards successfully loaded. Loaded dashboards 2018-09-10T08:39:45.358Z INFO elasticsearch/client.go:163 Elasticsearch url: http://localhost:9200 2018-09-10T08:39:45.361Z INFO elasticsearch/client.go:708 Connected to Elasticsearch version 6.4.2 2018-09-10T08:39:45.361Z INFO kibana/client.go:113 Kibana url: http://localhost:5601 2018-09-10T08:39:45.455Z WARN fileset/modules.go:388 X-Pack Machine Learning is not enabled Loaded machine learning job configurations

      Agora você pode iniciar e ativar o Filebeat:

      • sudo systemctl start filebeat
      • sudo systemctl enable filebeat

      Se você configurou seu Elastic Stack corretamente, o Filebeat começará a enviar seus registros de log e autorização para o Logstash, que então carregará esses dados no Elasticsearch.

      Para verificar se o Elasticsearch está realmente recebendo esses dados, consulte o index do Filebeat com este comando:

      • curl -XGET 'http://localhost:9200/filebeat-*/_search?pretty'

      Você verá uma saída semelhante a esta:

      Output

      ... { "took" : 32, "timed_out" : false, "_shards" : { "total" : 3, "successful" : 3, "skipped" : 0, "failed" : 0 }, "hits" : { "total" : 1641, "max_score" : 1.0, "hits" : [ { "_index" : "filebeat-6.4.2-2018.10.10", "_type" : "doc", "_id" : "H_bZ62UBB4D0uxFRu_h3", "_score" : 1.0, "_source" : { "@version" : "1", "message" : "Oct 10 06:22:36 elk systemd[1]: Reached target Local File Systems (Pre).", "@timestamp" : "2018-10-10T08:43:56.969Z", "host" : { "name" : "elk" }, "source" : "/var/log/syslog", "input" : { "type" : "log" }, "tags" : [ "beats_input_codec_plain_applied" ], "offset" : 296, "prospector" : { "type" : "log" }, "beat" : { "version" : "6.4.2", "hostname" : "elk", "name" : "elk" } } }, ...

      Se a sua saída mostrar 0 total hits, o Elasticsearch não está carregando nenhum registro sob o index que você pesquisou, e você precisará revisar sua configuração para verificar erros. Se você recebeu a saída esperada, continue para a próxima etapa, na qual veremos como navegar em alguns dos painéis do Kibana.

      Passo 5 — Explorando os Painéis do Kibana

      Vamos dar uma olhada no Kibana, a interface web que instalamos anteriormente.

      Em um navegador web, vá para o FQDN ou endereço IP público do seu servidor Elastic Stack. Depois de inserir as credenciais de login que você definiu no Passo 2, você verá a página inicial do Kibana:

      Clique no link Discover na barra de navegação à esquerda. Na página Discover, selecione o padrão de index predefinido filebeat-* para ver os dados do Filebeat. Por padrão, isso mostrará todos os dados do log nos últimos 15 minutos. Você verá um histograma com eventos de log, e algumas mensagens de log como abaixo:

      Aqui, você pode pesquisar e navegar pelos seus logs e também personalizar seu painel. Neste ponto, porém, não haverá muita coisa porque você está apenas coletando syslogs do seu servidor Elastic Stack.

      Use o painel esquerdo para navegar até a página Dashboard e pesquise pelos painéis do Filebeat System. Uma vez lá, você pode procurar os painéis de amostra que vêm com o módulo system do Filebeat.

      Por exemplo, você pode visualizar estatísticas detalhadas com base em suas mensagens do syslog:

      Você também pode ver quais usuários usaram o comando sudo e quando:

      Kibana tem muitos outros recursos, como gráficos e filtragem, então sinta-se livre para explorar.

      Conclusão

      Neste tutorial, você aprendeu como instalar e configurar o Elastic Stack para coletar e analisar logs do sistema. Lembre-se de que você pode enviar praticamente qualquer tipo de log ou dados indexados para o Logstash usando o Beats, mas os dados se tornam ainda mais úteis se forem analisados e estruturados com um filtro Logstash, pois isso transforma os dados em um formato consistente que pode ser lido facilmente pelo Elasticsearch.

      Por Justin Ellingwood e Vadym Kalsin



      Source link

      Como Instalar o Go no Ubuntu 18.04


      Introdução

      Go é uma linguagem de programação moderna desenvolvida no Google. Ela é cada vez mais popular para muitas aplicações e em muitas empresas, e oferece um conjunto robusto de bibliotecas. Este tutorial irá ajudá-lo a baixar e instalar a versão mais recente do Go (Go 1.10 no momento da publicação deste artigo), bem como construir uma aplicação Hello Word simples.

      Pré-requisitos

      Este tutorial assume que você tenha acesso a um sistema Ubuntu 18.04, configurado com um usuário não-root com privilégios sudo, como descrito em Configuração Inicial de servidor com Ubuntu 18.04.

      Passo 1 — Instalando o Go

      Nesta etapa, vamos instalar o Go no seu servidor.

      Para começar, conecte-se ao seu servidor Ubuntu via ssh:

      • ssh sammy@ip_do_seu_servidor

      Para instalar o Go, você precisará pegar a versão mais recente da página oficial de downloads do Go. No site você pode encontrar a URL para o tarball do binário da versão atual, juntamente com seu hash SHA256.

      Visite a página oficial de downloads do Go e encontre a URL para o taball do binário da versão atual, juntamente com seu hash SHA256. Certifique-se de estar em seu diretório home, e utilize curl para baixar o tarball:

      • cd ~
      • curl -O https://dl.google.com/go/go1.10.3.linux-amd64.tar.gz

      Em seguida, você pode usar o sha256sum para verificar o tarball:

      • sha256sum go1.10.3.linux-amd64.tar.gz

      Sample Output

      go1.10.3.linux-amd64.tar.gz fa1b0e45d3b647c252f51f5e1204aba049cde4af177ef9f2181f43004f901035 go1.10.3.linux-amd64.tar.gz

      Você terá um hash como aquele destacado na saída acima. Certifique-se de que coincide com o da página de downloads.

      A seguir, use o tar para extrair o tarball. A flag x diz ao tar para extrair, v diz a ele que queremos uma saída detalhada (uma listagem dos arquivos que estão sendo extraídos), e f diz a ele que especificaremos um arquivo.

      • tar xvf go1.10.3.linux-amd64.tar.gz

      Agora você deve ter um diretório chamado go em seu diretório home. Altere recursivamente o proprietário e o grupo do diretório go para root, e mova-o para /usr/local:

      • sudo chown -R root:root ./go
      • sudo mv go /usr/local

      Nota: Embora /usr/local/go seja a localização recomendada oficialmente, alguns usuários podem preferir ou requerer paths diferentes.

      Passo 2 — Definindo Paths do Go

      Nesta etapa, iremos definir alguns paths ou caminhos de arquivos em seu ambiente.

      Primeiro, defina o valor da raiz do Go, que diz ao Go onde procurar pelos seus arquivos.

      No final do arquivo, adicione esta linha:

      export GOPATH=$HOME/work
      export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
      

      Se você escolheu um local de instalação alternativo para o Go, em vez disso, adicione essas linhas ao mesmo arquivo. Este exemplo mostra os comandos se o Go estiver instalado no seu diretório home:

      export GOROOT=$HOME/go
      export GOPATH=$HOME/work
      export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
      

      Depois de colar a linha apropriada no seu perfil, salve e feche o arquivo. Em seguida, atualize seu perfil executando:

      Passo 3 — Testando Sua Instalação

      Agora que o Go está instalado e os paths estão defnidos para seu servidor, você pode testar para garantir que o Go esteja funcionando como esperado.

      Crie um novo diretório para o seu espaço de trabalho no Go, que é onde o Go irá compilar seus arquivos:

      Em seguida, crie uma hierarquia de diretórios nessa pasta por meio desse comando para criar seu arquivo de teste. Você pode substituir o valor usuário pelo seu nome de usuário do GitHub se você planeja usar o Git para fazer commit e armazenar seu código Go no GitHub. Se você não planeja usar o GitHub para armazenar e gerenciar seu código, sua estrutura de pastas pode ser algo diferente, como ~/my_project.

      • mkdir -p work/src/github.com/usuário/hello

      Após isso, você pode criar um arquivo simples de "Hello World".

      • nano ~/work/src/github.com/usuário/hello/hello.go

      Dentro do seu editor, cole o código abaixo, que utiliza o pacote main do Go, importa o componente de conteúdo de IO formatado, e define uma nova função para imprimir "Hello, World" ao ser executado.

      package main
      
      import "fmt"
      
      func main() {
          fmt.Printf("hello, worldn")
      }
      

      Este pograma imprimirá "hello, world" se ele for executado com sucesso, o que indicará que os programas do Go estão compilando corretamente. Salve e feche o arquivo, e então compile-o invocando o comando install:

      go install github.com/usuário/hello
      

      Com o arquivo compilado, você pode executá-lo simplesmente executando o comando:

      Se esse comando retornar "hello, world", então o Go está instalado e funcionando com sucesso. Você pode ver onde o binário 'hello' compilado está instalado usando o comando which:

      Output

      /home/usuário/work/bin/hello

      Conclusão

      Ao fazer o download e instalar o pacote Go mais recente e configurar seus paths, agora você tem um sistema pronto para usar no desenvolvimento com Go. Você pode encontrar e se inscrever em artigos adicionais sobre como instalar e usar o Go na nossa tag "Go"

      Por Brennen Bearnes



      Source link

      Como Instalar e Configurar o pgAdmin 4 no Modo Servidor


      Introdução

      O pgAdmin é uma plataforma opensource de administração e desenvolvimento para PostgreSQL e seus sistemas de gerenciamento de banco de dados relacionados. Escrito em Python e jQuery, ele suporta todos os recursos encontrados no PostgreSQL. Você pode utilizar o pgAdmin para fazer tudo, desde escrever consultas SQL básicas a monitorar seus bancos de dados e configurar arquiteturas de banco de dados avançadas.

      Neste tutorial, vamos passar pelo processo de instalação e configuração da versão mais recente do pgAdmin em um servidor Ubuntu 18.04, acessando o pgAdmin através de um navegador web, e conectando-o a um banco de dados PostgreSQL em seu servidor.

      Pré-requisitos

      Para completar este tutorial, você vai precisar de:

      Passo 1 — Instalando o pgAdmin e suas Dependências

      No momento da escrita desse tutorial, a versão mais recente do pgAdmin é a pgAdmin 4, enquanto a versão mais recente disponível através dos repositórios oficiais do Ubuntu é a pgAdmin 3. O pgAdmin 3 já não é suportado, e os mantenedores do projeto recomendam a instalação do pgAdmin 4. Neste passo, vamos passar pelo processo de instalação da versão mais recente do pgAdmin 4 dentro de um ambiente virtual (conforme recomendado pelo time de desenvolvimento do projeto) e pela instalação de suas dependências usando o apt.

      Para começar, atualize o índice de pacotes do seu servidor, se você não tiver feito isso recentemente:

      Em seguida, instale as seguintes dependências. Elas incluem a libgmp3-dev, uma biblioteca aritmética multiprecisão; libpq-dev,que inclui arquivos de cabeçalho e uma biblioteca estática que ajuda na comunicação com o backend do PostgreSQL; e libapache2-mod-wsgi-py3, um módulo do Apache que lhe permite hospedar aplicações web baseadas em Python dentro do Apache:

      • sudo apt install libgmp3-dev libpq-dev libapache2-mod-wsgi-py3

      Em seguida, crie alguns diretórios nos quais o pgAdmin armazenará seus dados de sessões, dados de armazenamento e logs:

      • sudo mkdir -p /var/lib/pgadmin4/sessions
      • sudo mkdir /var/lib/pgadmin4/storage
      • sudo mkdir /var/log/pgadmin4

      Depois, altere a propriedade desses diretórios para seu usuário e grupo não-root. Isto é necessário porque eles são de propriedade do usuário root, mas vamos instalar o pgAdmin em um ambiente virtual que pertence ao seu usuário não-root, e o processo de instalação envolve a criação de alguns arquivos dentro desses diretórios. Após a instalação, contudo, vamos alterar a propriedade para o usuário e grupo www-data para que ele possa ser servido via web:

      • sudo chown -R sammy:sammy /var/lib/pgadmin4
      • sudo chown -R sammy:sammy /var/log/pgadmin4

      A seguir, abra o seu ambiente virtual. Navegue até o diretório onde está o seu ambiente virtual e ative-o. Seguindo a convenção de nomes do prerequisite Python 3 tutorial, vamos até o diretório environments e ativamos o ambiente my_env.

      • cd environments/
      • source my_env/bin/activate

      Depois disso, faça o download do código-fonte do pgAdmin4 em sua máquina. Para encontrar a última versão do código-fonte, navegue até a página de download do pgAdmin 4 (Python Wheel) e clique no link da última versão (3.4, no momento da escrita desse texto). Isso o levará para uma página de Downloads no website do PostgreSQL. Estando lá, copie o link de arquivo que termina com .whl — o formato de pacote padrão de construção utilizado para as distribuições Python. Volte então ao seu terminal e execute o seguinte comando wget, certificando-se de substituir o link por aquele que você copiou do website do PostgreSQL, que fará o download do arquivo .whl para seu servidor:

      • wget https://ftp.postgresql.org/pub/pgadmin/pgadmin4/v3.4/pip/pgadmin4-3.4-py2.py3-none-any.whl

      Após isso, instale o pacote wheel, a implementação de referência do padrão de empacotamento wheel. Uma biblioteca Python, este pacote serve como uma extensão para a construção de wheels e inclui uma ferramenta de linha de comando para trabalhar com arquivos .whl:

      • python -m pip install wheel

      Então, instale o pacote pgAdmin com o seguinte comando:

      • python -m pip install pgadmin4-3.4-py2.py3-none-any.whl

      Isso cuida da instalação do pgAdmin e suas dependências. Antes de conectá-lo ao seu banco de dados, no entanto, você precisará fazer algumas alterações na configuração do programa.

      Passo 2 — Configurando o pgAdmin 4

      Embora o pgAdmin tenha sido instalado em seu servidor, existem ainda algumas etapas que você deve seguir para garantir que ele tenha as permissões e as configurações necessárias para permiti-lo servir corretamente a interface web.

      O arquivo principal de configuração do pgAdmin, config.py, é lido antes de qualquer outro arquivo de configuração. Seu conteúdo pode ser utilizado como um ponto de referência para outras configurações que podem ser especificadas nos outros arquivos de configuração do pgAdmin, mas para evitar erros imprevistos, você não deve editar o próprio arquivo config.py. Iremos adicionar algumas alterações de configuração em um novo arquivo, chamado config_local.py, que será lido depois do primeiro.

      Crie este arquivo agora utilizando seu editor de textos preferido. Aqui, vamos utilizar o nano:

      • nano my_env/lib/python3.6/site-packages/pgadmin4/config_local.py

      Em seu editor de textos, adicione o seguinte conteúdo:

      environments/my_env/lib/python3.6/site-packages/pgadmin4/config_local.py

      
      LOG_FILE = '/var/log/pgadmin4/pgadmin4.log'
      SQLITE_PATH = '/var/lib/pgadmin4/pgadmin4.db'
      SESSION_DB_PATH = '/var/lib/pgadmin4/sessions'
      STORAGE_DIR = '/var/lib/pgadmin4/storage'
      SERVER_MODE = True
      

      Aqui está o que estas cinco diretivas fazem:

      • LOG_FILE: isso define o arquivo no qual os logs do pgAdmin serão armazenados.

      • SQLITE_PATH: o pgAdmin armazena dados relacionados ao usuário em um banco de dados SQLite, e essa diretiva aponta o software pgAdmin para esse banco de dados de configuração. Como este arquivo está sob o diretório persistente /var/lib/pgadmin4/, seus dados de usuário não serão perdidos após a atualização.

      • SESSION_DB_PATH: especifica qual diretório será usado para armazenar dados da sessão.

      • STORAGE_DIR: define onde o pgAdmin armazenará outros dados, como backups e certificados de segurança.

      • SERVER_MODE: definir esta diretiva como True diz ao pgAdmin para rodar no modo Servidor, ao contrário do modo Desktop.

      Observe que cada um desses caminhos de arquivo aponta para os diretórios que você criou na Etapa 1.

      Depois de adicionar essas linhas, salve e feche o arquivo (pressione CTRL + X, seguido de Y e depois ENTER). Com essas configurações, execute o script de configuração do pgAdmin para definir suas credenciais de login:

      • python my_env/lib/python3.6/site-packages/pgadmin4/setup.py

      Depois de executar este comando, você verá um prompt solicitando seu endereço de e-mail e uma senha. Estas serão as suas credenciais de login quando você acessar o pgAdmin mais tarde, então lembre-se ou anote o que você digitar aqui:

      Output

      . . . Enter the email address and password to use for the initial pgAdmin user account: Email address: sammy@example.com Password: Retype password:

      Em seguida, desative seu ambiente virtual:

      Lembre-se dos caminhos de arquivos que você especificou no arquivo config_local.py. Esses arquivos são mantidos nos diretórios criados na Etapa 1, que atualmente são de propriedade do seu usuário não-root. Eles devem, no entanto, ser acessíveis pelo usuário e pelo grupo que está executando o seu servidor web. Por padrão, no Ubuntu 18.04, estes são o usuário e grupo www-data, portanto, atualize as permissões nos seguintes diretórios para dar ao www-data a propriedade sobre os dois:

      • sudo chown -R www-data:www-data /var/lib/pgadmin4/
      • sudo chown -R www-data:www-data /var/log/pgadmin4/

      Com isso, o pgAdmin está totalmente configurado. Contudo, o programa ainda não está sendo servido pelo seu servidor, então ele permanece inacessível. Para resolver isso, vamos configurar o Apache para servir o pgAdmin para que você possa acessar sua interface de usuário através de um navegador web.

      Passo 3 — Configurando o Apache

      O servidor web Apache utiliza virtual hosts para encpsular os detalhes de configuração e hospedar mais de um domínio a partir de um único servidor. Se você seguiu o tutorial de pré-requisitos do Apache, você pode ter configurado um exemplo de arquivo virtual host sob o nome example.com.conf, mas nesta etapa vamos criar um novo a partir do qual poderemos servir a interface web do pgAdmin.

      Para começar, certifique-se de que você está no seu diretório raiz:

      Em seguida, crie um novo arquivo em seu diretório /sites-available/ chamado pgadmin4.conf. Este será o arquivo de virtual host do seu servidor:

      • sudo nano /etc/apache2/sites-available/pgadmin4.conf

      Adicione o seguinte conteúdo a este arquivo, certificando-se de atualizar as partes destacadas para alinhar com sua própria configuração:

      /etc/apache2/sites-available/pgadmin4.conf

      
      <VirtualHost *>
          ServerName ip_do_seu_servidor
      
          WSGIDaemonProcess pgadmin processes=1 threads=25 python-home=/home/sammy/environments/my_env
          WSGIScriptAlias / /home/sammy/environments/my_env/lib/python3.6/site-packages/pgadmin4/pgAdmin4.wsgi
      
          <Directory "/home/sammy/environments/my_env/lib/python3.6/site-packages/pgadmin4/">
              WSGIProcessGroup pgadmin
              WSGIApplicationGroup %{GLOBAL}
              Require all granted
          </Directory>
      </VirtualHost>
      

      Salve e feche o arquivo de virtual host. Depois, utilize o script a2dissite para desativar o arquivo de virtual host padrão, 000-default.conf:

      • sudo a2dissite 000-default.conf

      Nota: Se você seguiu o tutorial de pré-requisitos do Apache, você já pode ter desabilitado o 000-default.conf e configurado um exemplo de arquivo de configuração do virtual host (chamado example.com.conf no pré-requisito). Se este for o caso, você precisará desabilitar o arquivo de virtual host example.com.conf com o seguinte comando:

      • sudo a2dissite example.com.conf

      Depois, use o script a2ensite para ativar seu arquivo de virtual host pgadmin4.conf. Isso irá criar um link simbólico do arquivo de virtual host no diretório /sites-available/ para o diretório /sites-enabled/:

      • sudo a2ensite pgadmin4.conf

      Após isso, teste para ver se a sintaxe do seu arquivo de configuração está correta:

      Se seu arquivo de configuração estiver em ordem, você verá Syntax OK. Se você vir um erro na saída, reabra o arquivo pgadmin4.conf e verifique novamente se o seu endereço IP e os caminhos de arquivo estão corretos, em seguida execute novamente o configtest.

      Quando você vir Sintax OK na sua saída, reinicie o serviço Apache para que ele leia o novo arquivo de virtual host:

      • sudo systemctl restart apache2

      Agora, o pgAdmin está totalmente instalado e configurado. A seguir, veremos como acessar o pgAdmin a partir de um navegador antes de conectá-lo ao seu banco de dados PostgreSQL.

      Passo 4 — Acessando o pgAdmin

      Em sua máquina local, abra o seu navegador preferido e navegue até o endereço IP do seu servidor:

      http://ip_do_seu_servidor
      

      Uma vez lá, você verá uma tela de login semelhante à seguinte:

      Insira as credenciais de login que você definiu no Passo 2, e você será levado para a Tela de Boas-vindas do pgAdmin:

      Agora que você confirmou que pode acessar a interface do pgAdmin, tudo o que resta a fazer é conectar o pgAdmin ao seu banco de dados PostgreSQL. Antes de fazer isso, porém, você precisará fazer uma pequena alteração na configuração do superusuário do PostgreSQL.

      Passo 5 — Configurando seu usuário do PostgreSQL

      Se você seguiu o tutorial de pré-requisitos do PostgreSQL, você já deve ter o PostgreSQL instalado em seu servidor com uma nova função de superusuário e uma configuração de banco de dados.

      Por padrão no PostgreSQL, você autentica como usuário do banco de dados usando o método de autenticação "Protocolo de Identificação", ou "ident". Isso envolve o PostgreSQL utilizar o nome de usuário do Ubuntu do cliente e usá-lo como o nome de usuário permitido do banco de dados. Isso pode permitir maior segurança em muitos casos, mas também pode causar problemas nos casos em que você deseja que um programa externo, como o pgAdmin, se conecte a um dos seus bancos de dados. Para resolver isso, vamos definir uma senha para esta função do PostgreSQL que permitirá ao pgAdmin se conectar ao seu banco de dados.

      A partir do seu terminal, abra o prompt do PostgreSQL sob sua função de superusuário:

      A partir do prompt do PostgreSQL, atualize o perfil do usuário para ter uma senha forte de sua escolha:

      • ALTER USER sammy PASSWORD 'senha';

      Agora, saia do prompt do PostgreSQL:

      Em seguida, volte para a interface do pgAdmin 4 em seu navegador e localize o menu Browser no lado esquerdo. Clique com o botão direito do mouse em Servers para abrir um menu de contexto, passe o mouse sobre Create e clique em Server….

      Isso fará com que uma janela apareça no seu navegador, na qual você inserirá informações sobre seu servidor, função e banco de dados.

      Na guia General, digite o nome para esse servidor. Isso pode ser qualquer coisa que você queira, mas talvez seja útil fazer algo descritivo. Em nosso exemplo, o servidor é chamado Sammy-server-1.

      A seguir, clique na aba Connection. No campo Host name/address, insira localhost. Port deve ser definida para 5432 por padrão, o que irá funcionar para essa configuração, pois é a porta padrão utilizada pelo PostgreSQL. Observe que esse banco de dados já deve estar criado em seu servidor.

      No campo Maintenance database, insira o nome do banco de dados ao qual você gostaria de se conectar. Em seguida, insira o nome de usuário e a senha do PostgreSQL que você configurou anteriormente nos campos Username e Password, respectivamente.

      Os campos vazios nas outras guias são opcionais, e é necessário preenchê-los apenas se você tiver uma configuração específica em mente na qual eles sejam necessários. Clique no botão Save e o banco de dados aparecerá sob Servers no menu Browser.

      Você conectou com sucesso o pgAdmin4 ao seu banco de dados PostgreSQL. Você pode fazer praticamente qualquer coisa no painel do pgAdmin que você faria no prompt do PostgreSQL. Para ilustrar isso, vamos criar uma tabela de exemplo e preenchê-la com alguns dados de amostra através da interface web.

      Passo 6 — Criando uma Tabela no Painel do pgAdmin

      No painel do pgAdmin, localize o menu Browser no lado esquerdo da janela. Clique no sinal de mais (+) próximo de Servers (1) para expandir o menu em árvore dentro dele. Em seguida, clique no sinal de mais à esquerda do servidor que você adicionou na etapa anterior (Sammy-server-1 em nosso exemplo), depois expanda Databases, o nome do banco de dados que você adicionou (sammy, em nosso exemplo), e então Schemas (1). Você deve ver um menu em árvore como o seguinte:

      Clique com o botão direito do mouse no item Tables da lista , depois passe o cursor sobre Create e clique em Table….

      Isso abrirá uma janela Create-Table. Sob a guia General dessa janela, insira um nome para a tabela. Isso pode ser qualquer coisa que você quiser, mas para manter as coisas simples, vamos nos referir a ela como table-01.

      Em seguida, navegue até a guia Columns e clique no sinal de + no canto superior direito da janela para adicionar algumas colunas. Ao adicionar uma coluna, você deve fornecer um Name ou nome e um Data type ou tipo de dados, e você pode precisar escolher um Length ou comprimento se for exigido pelo tipo de dados que você selecionou.

      Além disso, a documentação oficial do PostgreSQL afirma que adicionar uma chave primária ou primary key a uma tabela geralmente é a melhor prática. Uma chave primária é uma restrição que indica uma coluna específica ou conjunto de colunas que podem ser usadas como um identificador especial para linhas na tabela. Isso não é um requisito, mas se você quiser definir uma ou mais de suas colunas como a chave primária, alterne o botão mais à direita de No para Yes.

      Clique no botão Save para criar a tabela.

      Nesse ponto, você criou uma tabela e adicionou algumas colunas a ela. No entanto, as colunas ainda não contêm dados. Para adicionar dados à sua nova tabela, clique com o botão direito do mouse no nome da tabela no menu Browser, passe o cursor sobre Scripts e clique em INSERT Script.

      Isso abrirá uma nova tela no painel. No topo, você verá uma instrução INSERT parcialmente completa, com os nomes de tabela e coluna apropriados. Vá em frente e substitua os pontos de interrogação (?) por alguns dados fictícios, certificando-se de que os dados adicionados se alinham aos tipos de dados selecionados para cada coluna. Observe que você também pode adicionar várias linhas de dados através da adição de cada linha em um novo conjunto de parênteses, com cada conjunto de parênteses separados por uma vírgula, conforme mostrado no exemplo a seguir.

      Se desejar, sinta-se à vontade para substituir o script INSERT parcialmente concluído com este exemplo de comando INSERT:

      INSERT INTO public."table-01"(
          col1, col2, col3)
          VALUES ('Juneau', 14, 337), ('Bismark', 90, 2334), ('Lansing', 51, 556);
      

      Clique no ícone do raio (⚡) para executar o comando INSERT. Para visualizar a tabela e todos os dados nela, clique mais uma vez com o botão direito do mouse no nome da sua tabela no menu Browser, passe o cursor sobre View/Edit Data e selecione All Rows.

      Isso abrirá outro novo painel, abaixo do qual, na guia Data Output do painel inferior, você pode ver todos os dados contidos nessa tabela.

      Com isso, você criou com sucesso uma tabela e a preencheu com alguns dados por meio da interface web do pgAdmin. Claro, este é apenas um método que você pode usar para criar uma tabela através do pgAdmin. Por exemplo, é possível criar e preencher uma tabela usando SQL em vez do método baseado em GUI descrito nesta etapa.

      Conclusão

      Neste guia, você aprendeu como instalar o pgAdmin 4 a partir de um ambiente virtual Python, configurá-lo, servi-lo via web com o Apache e como conectá-lo a um banco de dados PostgreSQL. Além disso, este guia abordou um método que pode ser usado para criar e preencher uma tabela, mas o pgAdmin pode ser usado para muito mais do que apenas criar e editar tabelas.

      Para obter mais informações sobre como aproveitar ao máximo todos os recursos do pgAdmin, recomendamos que você veja a documentação do projeto. Você também pode aprender mais sobre o PostgreSQL através dos nossos Tutoriais da comunidade que abordam o assunto.

      Por Mark Drake



      Source link