One place for hosting & domains

      PostgreSQL

      Como Instalar e Utilizar o PostgreSQL no Ubuntu 18.04


      Introdução

      Sistemas de gerenciamento de banco de dados relacionados são um componente fundamental de muitos sites e aplicativos. Eles fornecem uma maneira estruturada de armazenar, organizar e acessar informações.

      O PostgreSQLou Postgres é um sistema de gerenciamento de banco de dados relacionados que fornece uma implementação da linguagem estruturada SQL. É uma escolha popular para muitos projetos pequenos e grandes e tem a vantagem de ser compatível com padrões e ter muitas funcionalidades avançadas como transações confiáveis e simultaneidade sem bloqueios de leitura.

      Este guia demonstra como instalar o Postgres em uma instância Ubuntu 18.04 VPS e também fornece instruções para a administração básica de banco de dados.

      Pré-requisitos

      Para acompanhar este tutorial, você precisará de um servidor Ubuntu 18.04 que tenha sido configurado seguindo nosso guia Configuração Inicial de Servidor para Ubuntu 18.04[. Após concluir este tutorial pré-requisito, seu servidor deve ter um usuário não-root com permissões sudo e um firewall básico.

      Passo 1 — Instalando o PostgreSQL

      Os repositórios padrão do Ubuntu contêm pacotes Postgres, para que você possa instalar esses usando o sistema de empacotamento apt.

      Uma vez que essa é a primeira vez que você usa o apt nesta sessão, atualize seu índice de pacotes local. Então, instale o pacote Postgres jutamente com um pacote -contrib que adiciona alguns serviços e funcionalidade adicionais:

      • sudo apt update
      • sudo apt install postgresql postgresql-contrib

      Agora que o software está instalado, podemos examinar como ele funciona e como ele pode ser diferente de sistemas similares de gerenciamento de banco de dados que você possa ter usado.

      Passo 2 — Usando as Roles PostgreSQL e Bancos de Dados

      Por padrão, o Postgres usa um conceito chamado “roles” para lidar com a autenticação e autorização. Essas são, de certa forma, semelhantes a contas regulares estilo Unix, mas o Postgres não distingue entre os usuários e os grupos e, ao invés disso, prefere o termo “role” mais flexível.

      Após a instalação, o Postgres é configurado para usar a autenticação ident, o que significa que ele associa os roles com uma conta do sistema Unix/Linux que combine. Se um role existe no Postgres, um nome de usuário Unix/Linux com o mesmo nome é capaz de fazer login como aquele role.

      O procedimento de instalação criou uma conta de usuário chamada postgres que está associada ao role padrão do Postgres. Para utilizar o Postgres, você pode logar naquela conta.

      Existem algumas maneiras de utilizar essa conta para acessar o Postgres.

      Mudando para a Conta postgres

      Mude para a conta postgres no seu servidor digitando:

      Agora você pode acessar um prompt Postgres imediatamente digitando:

      Isso irá logar você no prompt do PostgreSQL, e daqui você está livre para interagir com o sistema de gerenciamento de banco de dados imediatamente.

      Saia do prompt do PostgreSQL digitando:

      Isso irá trazer você de volta ao prompt de comando do Linux postgres.

      Acessando um Prompt do Postgres Sem Mudar de Contas

      Você também pode executar o comando que você quiser com a conta postgres diretamente com o sudo.

      Por exemplo, no último exemplo, você foi instruído a ir ao prompt do Postgres trocando primeiramente para o usuário postgres e então executando o psql para abrir o prompt do Postgres. Você poderia fazer isso em um passo executando o comando único psql como usuário postgres com sudo, dessa forma:

      Isso irá logar você diretamente no Postgres sem o shell bash intermediário.

      Novamente, você pode sair da sessão interativa Postgres digitando:

      Muitas formas de uso requerem mais de um role Postgres. Leia para aprender a configurá-los.

      Passo 3 — Criando um Novo Role

      Atualmente, você tem o role postgres configurado no banco de dados. Você pode criar novos roles na linha de comando com o comando createrole. A flag --interactive irá te solicitar o nome do novo role e também perguntar se ele deveria ter permissões de superusuário.

      Se você estiver logado com a conta postgres, você pode criar um novo usuário digitando:

      Se, ao invés disso, você preferir usar o sudo para cada comando sem mudar da sua conta usual, digite:

      • sudo -u postgres createuser --interactive

      O script irá te solicitar algumas escolhas e, com base nas suas respostas, executar os comandos corretos do Postgres para criar um usuário nas suas especificações.

      Output

      Enter name of role to add: sammy Shall the new role be a superuser? (y/n) y

      Você pode ter mais controle passando algumas bandeiras adicionais. Verifique as opções olhando para a página man:

      Sua instalação do Postgres agora tem um novo usuário, mas você ainda não adicionou nenhum banco de dados. A próxima seção descreve este processo.

      Passo 4 — Criando um Novo Banco de Dados

      Outra suposição que o sistema de autenticação do Postgres faz por padrão é que para qualquer role usado para logar, esse role terá um banco de dados com o mesmo nome que ele pode acessar.

      Isso significa que, se o usuário que você criou na última seção for chamado sammy, esse role irá tentar se conectar a um banco de dados que também seja chamado “sammy” por padrão. Você pode criar o banco de dados apropriado com o comando createdb.

      Se você estiver logado com a conta postgres, você digitaria algo como:

      Se, ao invés disso, você preferir usar o sudo para cada comando sem mudar da sua conta usual, você digitaria:

      • sudo -u postgres createdb sammy

      Esta flexibilidade proporciona vários caminhos para a criação de bancos de dados conforme necessário.

      Passo 5 — Abrindo um Prompt do Postgres com o Novo Role

      Para logar com a autenticação baseada no ident, você precisará de um usuário Linux com o mesmo nome que seu role e banco de dados do Postgres.

      Se você não tiver um usuário do Linux que combine disponível, você pode criar um com o comando adduser. Você terá que fazer isso através da sua conta não-root com privilégios sudo (ou seja, não logado como o usuário postgres):

      Uma vez que essa nova conta estiver disponível, você pode ou mudar e se conectar ao banco de dados digitando:

      Ou você pode fazer isso em linha:

      Este comando irá logar você automaticamente, supondo que todos os componentes tenham sido configurados corretamente.

      Se você quiser que seu usuário se conecte a um banco de dados diferente, você pode fazer isso especificando o banco de dados dessa forma:

      Uma vez logado, você pode verificar sua informação de conexão atual digitando:

      Output

      You are connected to database "sammy" as user "sammy" via socket in "/var/run/postgresql" at port "5432".

      Isso é útil se você estiver se conectando a bancos de dados fora do padrão ou com usuários que não sejam padrão.

      Passo 6 — Criando e Deletando Tabelas

      Agora que você sabe se conectar ao sistema de banco de dados do PostgreSQL, você pode aprender algumas tarefas básicas de gerenciamento do Postgres.

      Primeiro, crie uma tabela para armazenar alguns dados. Como um exemplo, uma tabela que descreva alguns equipamentos do playground.

      A sintaxe básica para este comando é a seguinte:

      CREATE TABLE table_name (
          column_name1 col_type (field_length) column_constraints,
          column_name2 col_type (field_length),
          column_name3 col_type (field_length)
      );
      

      Como você pode ver, esses comandos dão à tabela um nome e então definem as colunas, além do tipo de coluna e o comprimento máximo dos dados do campo. Você também pode adicionar de modo opcional tabelas de restrições para cada coluna.

      Você pode aprender mais sobre como criar e gerenciar tabelas no Postgres aqui.

      Para fins demonstrativos, crie uma tabela simples como essa:

      CREATE TABLE playground (
          equip_id serial PRIMARY KEY,
          type varchar (50) NOT NULL,
          color varchar (25) NOT NULL,
          location varchar(25) check (location in ('north', 'south', 'west', 'east', 'northeast', 'southeast', 'southwest', 'northwest')),
          install_date date
      );
      

      Estes comandos criarão uma tabela que inventaria o equipamento do playground. Isso começa com um ID do equipamento que é do tipo serial. Este tipo de dado é um número inteiro de incremento automático. Você também deu a essa coluna a restrição da primary key, que significa que os valores devem ser únicos e não nulos.

      Para duas das colunas (equip_id e install_date), os comandos não especificam um comprimento de campo. Isso é porque alguns tipos de coluna não requerem um comprimento específico porque o comprimento é implícito pelo tipo.

      Os dois comandos seguintes criam colunas para o type e color do equipamento respectivamente, cada um dos quais não pode ser vazio. O comando seguinte a esses cria uma coluna location e cria uma restrição que exige que o valor seja um de oito valores possíveis. O último comando cria uma coluna de data que grava a data na qual você instalou o equipamento.

      Você pode ver sua nova tabela digitando:

      Output

      List of relations Schema | Name | Type | Owner --------+-------------------------+----------+------- public | playground | table | sammy public | playground_equip_id_seq | sequence | sammy (2 rows)

      Sua tabela do playground está aqui, mas também há algo chamado playground_equip_id_seq que é do tipo sequence. Esta é uma representação do tipo serial que você deu à sua coluna equip_id Isso mantém o rastro do próximo número na sequência e é criado automaticamente para colunas deste tipo.

      Se você quiser ver apenas a tabela sem a sequência, você pode digitar:

      Output

      List of relations Schema | Name | Type | Owner --------+------------+-------+------- public | playground | table | sammy (1 row)

      Passo 7 — Adicionando, Consultando e Deletando Dados em uma Tabela

      Agora que você tem uma tabela, você pode inserir alguns dados nela.

      Como um exemplo, adicione um slide e um swing chamando a tabela na qual você queira adicionar, nomeando as colunas e então fornecendo dados para cada coluna, desta forma:

      • INSERT INTO playground (type, color, location, install_date) VALUES ('slide', 'blue', 'south', '2017-04-28');
      • INSERT INTO playground (type, color, location, install_date) VALUES ('swing', 'yellow', 'northwest', '2018-08-16');

      Você deve tomar cuidado ao introduzir os dados para evitar alguns problemas comuns. Por exemplo, não envolva os nomes das colunas em aspas, mas os valores de coluna que você digitar precisam de aspas.

      Outra coisa para ficar atento é não digitar um valor para a coluna equip_id. Isso acontece porque isso é gerado automaticamente sempre que uma nova linha na tabela seja criada.

      Recupere a informação que você adicionou digitando:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+--------+-----------+-------------- 1 | slide | blue | south | 2017-04-28 2 | swing | yellow | northwest | 2018-08-16 (2 rows)

      Aqui, você pode ver que seu equip_id foi preenchido com sucesso e que todos os seus outros dados foram organizados corretamente.

      Se o slide no playground falhar e você tiver que removê-lo, você também pode remover a linha da sua tabela digitando:

      • DELETE FROM playground WHERE type = 'slide';

      Consulte a tabela novamente:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+--------+-----------+-------------- 2 | swing | yellow | northwest | 2018-08-16 (1 row)

      Você percebe que seu slide já não é uma parte da tabela.

      Passo 8 — Adicionando e Deletando Colunas de uma Tabela

      Após criar uma tabela, você pode modificá-la para adicionar ou remover colunas com facilidade. Adicione uma coluna para mostrar a última visita de manutenção para cada peça de equipamento digitando:

      • ALTER TABLE playground ADD last_maint date;

      Se você ver sua informação da tabela novamente, você verá que a nova coluna foi adicionada (mas nenhum dado foi adicionado):

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date | last_maint ----------+-------+--------+-----------+--------------+------------ 2 | swing | yellow | northwest | 2018-08-16 | (1 row)

      Deletar uma coluna é também bastante simples. Se você descobrir que sua equipe de trabalho usa uma ferramenta separada para acompanhar o histórico de manutenção, você pode deletar da coluna digitando:

      • ALTER TABLE playground DROP last_maint;

      Isso apaga a coluna last_maint e quaisquer valores encontrados nela, mas deixa todos os outros dados intactos.

      Passo 9 — Atualizando os Dados em uma Tabela

      Até agora, você aprendeu a adicionar registros a uma tabela e como deletá-los, mas este tutorial ainda não cobriu como modificar os itens existentes.

      Você pode atualizar os valores de um item existente consultando o registro que você quiser e definindo a coluna para o valor que você deseja usar. Você pode consultar o registro “swing” (isto irá corresponder a cada swing na sua tabela) e alterar sua cor para “vermelho”. Isso pode ser útil se você der ao conjunto swing um trabalho de pintura:

      • UPDATE playground SET color = 'red' WHERE type = 'swing';

      Você pode verificar se a operação foi bem sucedida consultando os dados novamente:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+-------+-----------+-------------- 2 | swing | red | northwest | 2010-08-16 (1 row)

      Como você pode ver, seu slide agora está registrado como sendo vermelho.

      Conclusão

      Você agora está com o PostgreSQL configurado no seu servidor Ubuntu 18.04. No entanto, ainda há muito mais a aprender com o Postgres. Aqui estão mais alguns guias que cobrem como usar o Postgres:



      Source link

      Cómo instalar y utilizar PostgreSQL en Ubuntu 18.04


      Introducción

      Los sistemas de administración de bases de datos relacionales son un componente clave de una gran cantidad de aplicaciones y sitios web. Proporcionan una alternativa estructurada para almacenar la información, organizarla y acceder a ella.

      PostgreSQL, o Postgres, es un sistema de administración de bases de datos relacionales que proporciona una implementación del lenguaje de consulta SQL. Es una opción popular para muchos proyectos pequeños y grandes, y tiene la ventaja de cumplir con los estándares y ofrecer muchas características avanzadas, como transacciones confiables y simultaneidad sin bloqueos de lectura.

      En esta guía se muestra la forma de instalar Postgres en una instancia de VPS de Ubuntu 18.04 y también se proporcionan instrucciones para la administración básica de bases de datos.

      Requisitos previos

      Para completar este turorial, necesitará un servidor de Ubuntu 18.04 configurado conforme a nuestra guía de configuración inicial para servidores de Ubuntu 18.04. Una vez completado este tutorial de requisitos previos, su servidor debería contar con un usuario con permisos sudo no root y un firewall básico.

      Paso 1: Instalar PostgreSQL

      Los repositorios predeterminados de Ubuntu contienen paquetes de Postgres, para que pueda instalarlos utilizando el sistema de empaquetado apt.

      Dado que es la primera vez que utiliza apt en esta sesión, actualice su índice local de paquetes. Luego, instale el paquete de Postgres junto con un paquete -contrib, que agrega algunas utilidades y funcionalidades adicionales:

      • sudo apt update
      • sudo apt install postgresql postgresql-contrib

      Ahora que el software está instalado, podemos revisar su funcionamiento y la forma en que puede diferenciarse de otros sistemas de administración de bases de datos similares que pueda haber utilizado.

      Paso 2: Utilizar roles y bases de datos de PostgreSQL

      Por defecto, Postgress utiliza un concepto llamado “roles” para gestionar la autenticación y la autorización. Estos son, en algunos aspectos, parecidos a las cuentas normales de estilo Unix, pero Postgres no distingue entre los usuarios y los grupos, y en su lugar prefiere el término más flexible de “rol”.

      Tras la instalación, Postgres se configura para usar la autenticación ident. Esto significa que asocia los roles de Postgres con una cuenta de sistema Unix o Linux correspondiente. Si existe un rol dentro de Postgres, un nombre de usuario de Unix o Linux con el mismo nombre puede iniciar sesión ocupando ese rol.

      El procedimiento de instalación creó una cuenta de usuario llamada postgres, que se asocia con el rol predeterminado de Postgres. Para usar Postgres, puede iniciar sesión en esa cuenta.

      Existen algunas maneras de usar esta cuenta para acceder a Postgres.

      Cambiar a la cuenta de postgres

      Cambie a la cuenta de postgres en su servidor escribiendo lo siguiente:

      Ahora podrá acceder de inmediato a una linea de comandos de Postgres escribiendo lo siguiente:

      Esto le permitirá acceder a la línea de comandos de PostgreSQL y desde esta podrá interactuar de inmediato con el sistema de administración de bases de datos.

      Salga de la línea de comandos de PostgreSQL escribiendo lo siguiente:

      Con esto, regresará a la línea de comandos de Linux de postgres.

      Acceder a una línea de comandos de Postgres sin cambiar de cuenta

      También puede ejecutar el comando que desee con la cuenta de postgres de forma directa a través de sudo.

      Por ejemplo, en el último caso se le indicó acceder a la línea de comandos de Postgres pasando primero al usuario de postgres y luego ejecutando psql para abrir la línea de comandos de Postgres. Puede realizarlo en un solo paso ejecutando el comando único psql como usuario de postgres con sudo, como se muestra:

      Esto le permitirá iniciar sesión de forma directa en Postgres sin el shell bash intermediario entre ellos.

      De nuevo, puede salir de la sesión interactiva de Postgres escribiendo lo siguiente:

      Para muchos casos de uso se requiere más de un rol de postgres. Continúe leyendo para saber como configurar estos roles.

      Paso 3: Crear un nuevo rol

      En este momento, solo tiene el rol de postgres configurado dentro de la base de datos. Puede crear nuevos roles desde la línea de comandos con el comando createrole. El indicador --interactive le solicitará el nombre del nuevo rol y también le preguntará si debería tener permisos de superusuario.

      Si inició sesión a través de la cuenta de postgres, puede crear un nuevo usuario escribiendo lo siguiente:

      Si, como alternativa, prefiere usar sudo para cada comando sin dejar de usar su cuenta normal, escriba lo siguiente:

      • sudo -u postgres createuser --interactive

      El script le mostrará algunas opciones y, según sus respuestas, ejecutará los comandos correctos de Postgres para crear un usuario conforme a sus especificaciones.

      Output

      Enter name of role to add: sammy Shall the new role be a superuser? (y/n) y

      Puede obtener un mayor control pasando algunos indicadores adicionales. Consulte las opciones visitando la página de man:

      Ahora su instalación de Postgres tiene un usuario nuevo, pero aún no agregó bases de datos. En la sección siguiente se describe este proceso.

      Paso 4: Crear una nueva base de datos

      Otra suposición que el sistema de autenticación de Postgres realiza por defecto es que para cualquier rol utilizado en el inicio de sesión habrá una base de datos con el mismo nombre al que este podrá acceder.

      Esto significa que, si el usuario que creó en la última sección se llama sammy, ese rol intentará conectarse con una base de datos que por defecto también se llama “sammy”. Puede crear la base de datos apropiada con el comando createdb.

      Si inició sesión a través de la cuenta de postgres, escribiría algo similar a lo siguiente:

      Si, como alternativa, prefiere utilizar sudo para cada comando sin dejar de emplear su cuenta normal, escribiría lo siguiente:

      • sudo -u postgres createdb sammy

      Esta flexibilidad ofrece varias vías para crear bases de datos cuando sea necesario.

      Paso 5: Abrir una línea de comandos de Postgres con el nuevo rol

      Para iniciar sesión con la autenticación basada en ident, necesitará un usuario de Linux con el mismo nombre de su rol y su base de datos de Postgres.

      Si no tiene un usuario disponible de Linux que coincida, puede crear uno con el comando adduser. Deberá hacerlo desde su cuenta no root con privilegios sudo (es decir, sin iniciar sesión como usuario de postgres):

      Una vez que esté disponible esta cuenta nueva, podrá cambiar y conectarse a la base de datos escribiendo lo siguiente:

      También podrá hacerlo de forma directa:

      Este comando le permitirá iniciar sesión de forma automática, suponiendo que todos los componentes se hayan configurado de forma correcta.

      Si desea que su usuario se conecte a una base de datos diferente, puede lograrlo especificando la base de datos de esta manera:

      Ya que inició sesión, puede verificar la información de su conexión actual escribiendo lo siguiente:

      Output

      You are connected to database "sammy" as user "sammy" via socket in "/var/run/postgresql" at port "5432".

      Esto resultará útil si se conecta a bases de datos no predeterminadas o con usuarios no predeterminados.

      Paso 6: Crear y eliminar tablas

      Ahora que sabe cómo conectarse al sistema de bases de datos de PostgreSQL, puede aprender algunas tareas básicas de administración de Postgres.

      Primero, cree una tabla para almacenar datos. A modo de ejemplo, puede ser una tabla en la que se describan algunos equipos para áreas recreativas.

      La sintaxis básica de este comando es la siguiente:

      CREATE TABLE table_name (
          column_name1 col_type (field_length) column_constraints,
          column_name2 col_type (field_length),
          column_name3 col_type (field_length)
      );
      

      Como puede observar, estos comandos otorgan un nombre a la tabla y luego definen las columnas, el tipo de columna y la extensión máxima de los datos de campo. De manera opcional, también puede añadir restricciones de tabla para cada columna.

      Podrá obtener más información sobre cómo crear y administrar tablas en Postgres aquí.

      Para fines demostrativos, cree una tabla sencilla como la siguiente:

      CREATE TABLE playground (
          equip_id serial PRIMARY KEY,
          type varchar (50) NOT NULL,
          color varchar (25) NOT NULL,
          location varchar(25) check (location in ('north', 'south', 'west', 'east', 'northeast', 'southeast', 'southwest', 'northwest')),
          install_date date
      );
      

      Con estos comandos se creará una tabla que hará un inventario de los equipos para áreas recreativas. Esto comienza con un ID de equipo, que es del tipo serial. Este tipo de dato es un número entero que se incrementa de forma automática. También asignó a esta columna la restricción de primary key , lo cual significa que los valores deben ser únicos y no nulos.

      Para dos de las columnas (equip_id e install_date), los comandos no especifican una extensión de campo. Esto se debe a que algunos tipos de columna no requieren una extensión específica porque la extensión está implícita en el tipo.

      Con los dos comandos próximos se crean columnas para type y color del equipo respectivamente. Estas no pueden estar vacías. Después de esto, el comando crea una columna location y una restricción según la cual el valor debe ser uno de los ocho posibles. Con el último comando, se crea una columna de fecha en la cual se registra la fecha en la que usted instaló el equipo.

      Puede ver su tabla nueva escribiendo lo siguiente:

      Output

      List of relations Schema | Name | Type | Owner --------+-------------------------+----------+------- public | playground | table | sammy public | playground_equip_id_seq | sequence | sammy (2 rows)

      Su tabla de áreas de recreación se encuentra aquí, pero también existe algo llamado playground_equip_id_seq que responde al tipo sequence. Esto es una representación del tipo serial que usted atribuyó a su columna de equip_id. Esto realiza un seguimiento del número que sigue en la secuencia y se genera de forma automática para columnas de este tipo.

      Si desea ver solo la tabla sin la secuencia, puede escribir lo siguiente:

      Output

      List of relations Schema | Name | Type | Owner --------+------------+-------+------- public | playground | table | sammy (1 row)

      Paso 7: Agregar, consultar y eliminar datos en una tabla

      Ahora que dispone de una tabla, puede insertar datos en ella.

      A modo de ejemplo, agregue un tobogán y un columpio llamando a la tabla en la que desea realizar la adición, nombre las columnas y luego proporcione datos para cada una de ellas, como se muestra:

      • INSERT INTO playground (type, color, location, install_date) VALUES ('slide', 'blue', 'south', '2017-04-28');
      • INSERT INTO playground (type, color, location, install_date) VALUES ('swing', 'yellow', 'northwest', '2018-08-16');

      Debe tener cuidado al ingresar los datos para evitar algunos errores comunes. Para empezar, no escriba los nombres de las columnas entre comillas. Estás sí se necesitarán para los valores de la columna que ingresó.

      Otro aspecto que debe tener en cuenta es no ingresar un valor para la columna equip_id. Esto se debe a que se genera de forma automática cuando se crea una nueva fila en la tabla.

      Recupere la información que agregó escribiendo lo siguiente:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+--------+-----------+-------------- 1 | slide | blue | south | 2017-04-28 2 | swing | yellow | northwest | 2018-08-16 (2 rows)

      Aquí, puede ver que su equip_id se completó con éxito y que todos sus otros datos se organizaron de forma correcta.

      Si el tobogán del área de recreación se daña y tiene que eliminarlo, también puede eliminar la fila de su tabla escribiendo lo siguiente:

      • DELETE FROM playground WHERE type = 'slide';

      Consulte la tabla de nuevo:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+--------+-----------+-------------- 2 | swing | yellow | northwest | 2018-08-16 (1 row)

      Observará que su tobogán ya no se encuentra en la tabla.

      Paso 8: Agregar y eliminar columnas en una tabla

      Después de crear una tabla, puede modificarla para agregar o eliminar las columnas con relativa facilidad. Agregue una columna para mostrar la última visita de mantenimiento por cada equipo escribiendo lo siguiente:

      • ALTER TABLE playground ADD last_maint date;

      Si vuelve a visualizar la información de su tabla, observará que se agregó la nueva columna (pero no se ingresaron datos):

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date | last_maint ----------+-------+--------+-----------+--------------+------------ 2 | swing | yellow | northwest | 2018-08-16 | (1 row)

      Eliminar una columna es igual de sencillo. Si determina que su equipo de trabajo utiliza una herramienta separada para dar seguimiento al historial de mantenimiento, puede eliminar la columna escribiendo lo siguiente:

      • ALTER TABLE playground DROP last_maint;

      Con esto, se eliminan la columna last_maint y los valores que se encuentren en ella, pero deja intactos todos los demás datos.

      Paso 9: Actualizar datos de una tabla

      Hasta ahora, a través de este tutorial aprendió a agregar registros a una tabla y a eliminarlos de ella, pero aún no se abordó la forma de modificar los registros existentes.

      Puede actualizar los valores de una entrada existente buscando el registro que desee y fijando el valor que prefiera utilizar para la columna. Puede consultar el registro “columpio” (coincidirá con *cada *columpio de su tabla) y cambiar el color a “rojo”. Esto podría resultar útil si pintara el columpio:

      • UPDATE playground SET color = 'red' WHERE type = 'swing';

      Puede verificar la eficacia de la operación consultando los datos de nuevo:

      • SELECT * FROM playground;

      Output

      equip_id | type | color | location | install_date ----------+-------+-------+-----------+-------------- 2 | swing | red | northwest | 2010-08-16 (1 row)

      Como puede ver, ahora el color registrado de su tobogán será el rojo.

      Conclusión

      De esta manera, habrá configurado PostgreSQL en su servidor de Ubuntu 18.04. Sin embargo, aún queda *mucho *más por aprender con Postgres. A continuación, se ofrecen algunas guías más en las que se abarca el uso de Postgres:



      Source link

      Como Analisar as Estatísticas do Banco de Dados PostgreSQL Gerenciado Usando o Elastic Stack no Ubuntu 18.04


      O autor escolheu o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O monitoramento de banco de dados é o processo contínuo de rastrear sistematicamente várias métricas que mostram como o banco de dados está se comportando. Ao observar os dados de desempenho, você pode obter informações valiosas e identificar possíveis gargalos, além de encontrar maneiras adicionais de melhorar o desempenho do banco de dados. Esses sistemas geralmente implementam alertas que notificam os administradores quando as coisas dão errado. As estatísticas coletadas podem ser usadas não apenas para melhorar a configuração e o fluxo de trabalho do banco de dados, mas também para os aplicativos clientes.

      Os benefícios da utilização do Elastic Stack (ELK stack) para monitorar seu banco de dados gerenciado, é seu excelente suporte para pesquisa e a capacidade de ingerir novos dados muito rapidamente. Ele não se destaca na atualização dos dados, mas esse trade-off é aceitável para fins de monitoramento e logs, onde dados passados quase nunca são alterados. O Elasticsearch oferece meios poderosos de consultar os dados, que você pode usar através do Kibana para entender melhor como o banco de dados se sai em diferentes períodos de tempo. Isso permitirá que você correlacione a carga do banco de dados com eventos da vida real para obter informações sobre como o banco de dados está sendo usado.

      Neste tutorial, você importará métricas de banco de dados geradas pelo coletor de estatísticas do PostgreSQL no Elasticsearch via Logstash. Isso implica em configurar o Logstash para extrair dados do banco de dados usando o conector JDBC do PostgreSQL para enviá-los ao Elasticsearch para indexação imediatamente após. Os dados importados podem ser analisados e visualizados posteriormente no Kibana. Então, se seu banco de dados for novo, você usará o pgbench, uma ferramenta de benchmarking do PostgreSQL, para criar visualizações mais interessantes. No final, você terá um sistema automatizado buscando as estatísticas do PostgreSQL para análise posterior.

      Pré-requisitos

      Passo 1 — Configurando o Logstash e o Driver JDBC para PostgreSQL

      Nesta seção, você instalará o Logstash e fará o download do driver JDBC para PostgreSQL para que o Logstash possa se conectar ao seu banco de dados gerenciado.

      Comece instalando o Logstash com o seguinte comando:

      • sudo apt install logstash -y

      Depois que o Logstash estiver instalado, habilite o serviço para iniciar automaticamente na inicialização:

      • sudo systemctl enable logstash

      O Logstash é escrito em Java, portanto, para conectar-se ao PostgreSQL, é necessário que a biblioteca JDBC (Java Database Connectivity) do PostgreSQL esteja disponível no sistema em que está sendo executado. Por causa de uma limitação interna, o Logstash carregará adequadamente a biblioteca apenas se for encontrada no diretório /usr/share/logstash/logstash-core/lib/jars, onde armazena bibliotecas de terceiros que ele utiliza.

      Vá para a página de download da biblioteca JDBC e copie o link para a versão mais recente. Em seguida, faça o download usando curl executando o seguinte comando:

      • sudo curl https://jdbc.postgresql.org/download/postgresql-42.2.6.jar -o /usr/share/logstash/logstash-core/lib/jars/postgresql-jdbc.jar

      No momento da escrita deste tutorial, a versão mais recente da biblioteca era a 42.2.6, com o Java 8 como a versão runtime suportada. Certifique-se de baixar a versão mais recente; emparelhando-a com a versão Java correta que tanto o JDBC quanto o Logstash suportam.

      O Logstash armazena seus arquivos de configuração em /etc/logstash/conf.d e armazena a si próprio em /usr/share/logstash/bin. Antes de criar uma configuração que coletará estatísticas do seu banco de dados, será necessário ativar o plug-in JDBC no Logstash executando o seguinte comando:

      • sudo /usr/share/logstash/bin/logstash-plugin install logstash-input-jdbc

      Você instalou o Logstash usando o apt e baixou a biblioteca JDBC do PostgreSQL para que o Logstash possa usá-la para conectar-se ao seu banco de dados gerenciado. Na próximo passo, você configurará o Logstash para coletar dados estatísticos dele.

      Passo 2 — Configurando o Logstash Para Coletar Estatísticas

      Nesta seção, você configurará o Logstash para coletar métricas do seu banco de dados PostgreSQL gerenciado.

      Você configurará o Logstash para monitorar três bancos de dados de sistema no PostgreSQL, a saber:

      • pg_stat_database: fornece estatísticas sobre cada banco de dados, incluindo seu nome, número de conexões, transações, rollbacks, linhas retornadas ao consultar o banco de dados, deadlocks e assim por diante. Possui um campo stats_reset, que especifica quando as estatísticas foram zeradas pela última vez.
      • pg_stat_user_tables: fornece estatísticas sobre cada tabela criada pelo usuário, como o número de linhas inseridas, excluídas e atualizadas.
      • pg_stat_user_indexes: coleta dados sobre todos os índices em tabelas criadas pelo usuário, como o número de vezes que um índice específico foi consultado.

      Você armazenará a configuração para indexar as estatísticas do PostgreSQL no Elasticsearch em um arquivo chamado postgresql.conf no diretório /etc/logstash/conf.d, onde o Logstash armazena arquivos de configuração. Quando iniciado como um serviço, ele será executado automaticamente em segundo plano.

      Crie o postgresql.conf usando seu editor de textos favorito (por exemplo, o nano):

      • sudo nano /etc/logstash/conf.d/postgresql.conf

      Adicione as seguintes linhas:

      /etc/logstash/conf.d/postgresql.conf

      input {
              # pg_stat_database
              jdbc {
                      jdbc_driver_library => ""
                      jdbc_driver_class => "org.postgresql.Driver"
                      jdbc_connection_string => "jdbc:postgresql://host:port/defaultdb"
                      jdbc_user => "username"
                      jdbc_password => "password"
                      statement => "SELECT * FROM pg_stat_database"
                      schedule => "* * * * *"
                      type => "pg_stat_database"
              }
      
              # pg_stat_user_tables
              jdbc {
                      jdbc_driver_library => ""
                      jdbc_driver_class => "org.postgresql.Driver"
                      jdbc_connection_string => "jdbc:postgresql://host:port/defaultdb"
                      jdbc_user => "username"
                      jdbc_password => "password"
                      statement => "SELECT * FROM pg_stat_user_tables"
                      schedule => "* * * * *"
                      type => "pg_stat_user_tables"
              }
      
              # pg_stat_user_indexes
              jdbc {
                      jdbc_driver_library => ""
                      jdbc_driver_class => "org.postgresql.Driver"
                      jdbc_connection_string => "jdbc:postgresql://host:port/defaultdb"
                      jdbc_user => "username"
                      jdbc_password => "password"
                      statement => "SELECT * FROM pg_stat_user_indexes"
                      schedule => "* * * * *"
                      type => "pg_stat_user_indexes"
              }
      }
      
      output {
              elasticsearch {
                      hosts => "http://localhost:9200"
                      index => "%{type}"
              }
      }
      

      Lembre-se de substituir host pelo seu endereço de host, port pela porta à qual você pode se conectar ao seu banco de dados, username pelo nome de usuário do banco de dados e password pela sua senha. Todos esses valores podem ser encontrados no Painel de Controle do seu banco de dados gerenciado.

      Nesta configuração, você define três entradas JDBC e uma saída Elasticsearch. As três entradas extraem dados dos bancos de dados pg_stat_database, pg_stat_user_tables e pg_stat_user_indexes, respectivamente. Todos eles definem o parâmetro jdbc_driver_library como uma string vazia, porque a biblioteca JDBC do PostgreSQL está em uma pasta que o Logstash carrega automaticamente.

      Em seguida, eles definem o jdbc_driver_class, cujo valor é específico da biblioteca JDBC, e fornecem uma jdbc_connection_string, que detalha como se conectar ao banco de dados. A parte jdbc: significa que é uma conexão JDBC, enquanto postgres:// indica que o banco de dados de destino é o PostgreSQL. Em seguida, vem o host e a porta do banco de dados e, após a barra, você também especifica um banco de dados ao qual se conectar; isso ocorre porque o PostgreSQL exige que você esteja conectado a um banco de dados para poder emitir quaisquer consultas. Aqui, ele está definido como o banco de dados padrão que sempre existe e não pode ser excluído, apropriadamente denominado de defaultdb.

      Em seguida, eles definem um nome de usuário e a senha do usuário através do qual o banco de dados será acessado. O parâmetro statement contém uma consulta SQL que deve retornar os dados que você deseja processar — nessa configuração, ele seleciona todas as linhas do banco de dados apropriado.

      O parâmetro schedule aceita uma string na sintaxe do cron que define quando o Logstash deve executar esta entrada; omiti-lo completamente fará com que o Logstash a execute apenas uma vez. Especificando * * * * *, como você fez aqui, dirá ao Logstash para executá-la a cada minuto. Você pode especificar sua própria string do cron se desejar coletar dados em diferentes intervalos.

      Há apenas uma saída, que aceita dados de três entradas. Todas elas enviam dados para o Elasticsearch, que está sendo executado localmente e pode ser acessado em http://localhost:9200. O parâmetro index define para qual índice do Elasticsearch ele enviará os dados e seu valor é passado no campo type da entrada.

      Quando você terminar de editar, salve e feche o arquivo.

      Você configurou o Logstash para reunir dados de várias tabelas estatísticas do PostgreSQL e enviá-los ao Elasticsearch para armazenamento e indexação. Em seguida, você executará o Logstash para testar a configuração.

      Passo 3 — Testando a Configuração do Logstash

      Nesta seção, você testará a configuração executando o Logstash para verificar se ele extrairá os dados corretamente. Em seguida, você executará essa configuração em segundo plano, configurando-a como um pipeline do Logstash.

      O Logstash suporta a execução de uma configuração específica, passando seu caminho de arquivo para o parâmetro -f. Execute o seguinte comando para testar sua nova configuração da último passo:

      • sudo /usr/share/logstash/bin/logstash -f /etc/logstash/conf.d/postgresql.conf

      Pode levar algum tempo até que ele mostre qualquer saída, que será semelhante a esta:

      Output

      Thread.exclusive is deprecated, use Thread::Mutex WARNING: Could not find logstash.yml which is typically located in $LS_HOME/config or /etc/logstash. You can specify the path using --path.settings. Continuing using the defaults Could not find log4j2 configuration at path /usr/share/logstash/config/log4j2.properties. Using default config which logs errors to the console [WARN ] 2019-08-02 18:29:15.123 [LogStash::Runner] multilocal - Ignoring the 'pipelines.yml' file because modules or command line options are specified [INFO ] 2019-08-02 18:29:15.154 [LogStash::Runner] runner - Starting Logstash {"logstash.version"=>"7.3.0"} [INFO ] 2019-08-02 18:29:18.209 [Converge PipelineAction::Create<main>] Reflections - Reflections took 77 ms to scan 1 urls, producing 19 keys and 39 values [INFO ] 2019-08-02 18:29:20.195 [[main]-pipeline-manager] elasticsearch - Elasticsearch pool URLs updated {:changes=>{:removed=>[], :added=>[http://localhost:9200/]}} [WARN ] 2019-08-02 18:29:20.667 [[main]-pipeline-manager] elasticsearch - Restored connection to ES instance {:url=>"http://localhost:9200/"} [INFO ] 2019-08-02 18:29:21.221 [[main]-pipeline-manager] elasticsearch - ES Output version determined {:es_version=>7} [WARN ] 2019-08-02 18:29:21.230 [[main]-pipeline-manager] elasticsearch - Detected a 6.x and above cluster: the `type` event field won't be used to determine the document _type {:es_version=>7} [INFO ] 2019-08-02 18:29:21.274 [[main]-pipeline-manager] elasticsearch - New Elasticsearch output {:class=>"LogStash::Outputs::ElasticSearch", :hosts=>["http://localhost:9200"]} [INFO ] 2019-08-02 18:29:21.337 [[main]-pipeline-manager] elasticsearch - Elasticsearch pool URLs updated {:changes=>{:removed=>[], :added=>[http://localhost:9200/]}} [WARN ] 2019-08-02 18:29:21.369 [[main]-pipeline-manager] elasticsearch - Restored connection to ES instance {:url=>"http://localhost:9200/"} [INFO ] 2019-08-02 18:29:21.386 [[main]-pipeline-manager] elasticsearch - ES Output version determined {:es_version=>7} [WARN ] 2019-08-02 18:29:21.386 [[main]-pipeline-manager] elasticsearch - Detected a 6.x and above cluster: the `type` event field won't be used to determine the document _type {:es_version=>7} [INFO ] 2019-08-02 18:29:21.409 [[main]-pipeline-manager] elasticsearch - New Elasticsearch output {:class=>"LogStash::Outputs::ElasticSearch", :hosts=>["http://localhost:9200"]} [INFO ] 2019-08-02 18:29:21.430 [[main]-pipeline-manager] elasticsearch - Elasticsearch pool URLs updated {:changes=>{:removed=>[], :added=>[http://localhost:9200/]}} [WARN ] 2019-08-02 18:29:21.444 [[main]-pipeline-manager] elasticsearch - Restored connection to ES instance {:url=>"http://localhost:9200/"} [INFO ] 2019-08-02 18:29:21.465 [[main]-pipeline-manager] elasticsearch - ES Output version determined {:es_version=>7} [WARN ] 2019-08-02 18:29:21.466 [[main]-pipeline-manager] elasticsearch - Detected a 6.x and above cluster: the `type` event field won't be used to determine the document _type {:es_version=>7} [INFO ] 2019-08-02 18:29:21.468 [Ruby-0-Thread-7: :1] elasticsearch - Using default mapping template [INFO ] 2019-08-02 18:29:21.538 [Ruby-0-Thread-5: :1] elasticsearch - Using default mapping template [INFO ] 2019-08-02 18:29:21.545 [[main]-pipeline-manager] elasticsearch - New Elasticsearch output {:class=>"LogStash::Outputs::ElasticSearch", :hosts=>["http://localhost:9200"]} [INFO ] 2019-08-02 18:29:21.589 [Ruby-0-Thread-9: :1] elasticsearch - Using default mapping template [INFO ] 2019-08-02 18:29:21.696 [Ruby-0-Thread-5: :1] elasticsearch - Attempting to install template {:manage_template=>{"index_patterns"=>"logstash-*", "version"=>60001, "settings"=>{"index.refresh_interval"=>"5s", "number_of_shards"=>1}, "mappings"=>{"dynamic_templates"=>[{"message_field"=>{"path_match"=>"message", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false}}}, {"string_fields"=>{"match"=>"*", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false, "fields"=>{"keyword"=>{"type"=>"keyword", "ignore_above"=>256}}}}}], "properties"=>{"@timestamp"=>{"type"=>"date"}, "@version"=>{"type"=>"keyword"}, "geoip"=>{"dynamic"=>true, "properties"=>{"ip"=>{"type"=>"ip"}, "location"=>{"type"=>"geo_point"}, "latitude"=>{"type"=>"half_float"}, "longitude"=>{"type"=>"half_float"}}}}}}} [INFO ] 2019-08-02 18:29:21.769 [Ruby-0-Thread-7: :1] elasticsearch - Attempting to install template {:manage_template=>{"index_patterns"=>"logstash-*", "version"=>60001, "settings"=>{"index.refresh_interval"=>"5s", "number_of_shards"=>1}, "mappings"=>{"dynamic_templates"=>[{"message_field"=>{"path_match"=>"message", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false}}}, {"string_fields"=>{"match"=>"*", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false, "fields"=>{"keyword"=>{"type"=>"keyword", "ignore_above"=>256}}}}}], "properties"=>{"@timestamp"=>{"type"=>"date"}, "@version"=>{"type"=>"keyword"}, "geoip"=>{"dynamic"=>true, "properties"=>{"ip"=>{"type"=>"ip"}, "location"=>{"type"=>"geo_point"}, "latitude"=>{"type"=>"half_float"}, "longitude"=>{"type"=>"half_float"}}}}}}} [INFO ] 2019-08-02 18:29:21.771 [Ruby-0-Thread-9: :1] elasticsearch - Attempting to install template {:manage_template=>{"index_patterns"=>"logstash-*", "version"=>60001, "settings"=>{"index.refresh_interval"=>"5s", "number_of_shards"=>1}, "mappings"=>{"dynamic_templates"=>[{"message_field"=>{"path_match"=>"message", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false}}}, {"string_fields"=>{"match"=>"*", "match_mapping_type"=>"string", "mapping"=>{"type"=>"text", "norms"=>false, "fields"=>{"keyword"=>{"type"=>"keyword", "ignore_above"=>256}}}}}], "properties"=>{"@timestamp"=>{"type"=>"date"}, "@version"=>{"type"=>"keyword"}, "geoip"=>{"dynamic"=>true, "properties"=>{"ip"=>{"type"=>"ip"}, "location"=>{"type"=>"geo_point"}, "latitude"=>{"type"=>"half_float"}, "longitude"=>{"type"=>"half_float"}}}}}}} [WARN ] 2019-08-02 18:29:21.871 [[main]-pipeline-manager] LazyDelegatingGauge - A gauge metric of an unknown type (org.jruby.specialized.RubyArrayOneObject) has been create for key: cluster_uuids. This may result in invalid serialization. It is recommended to log an issue to the responsible developer/development team. [INFO ] 2019-08-02 18:29:21.878 [[main]-pipeline-manager] javapipeline - Starting pipeline {:pipeline_id=>"main", "pipeline.workers"=>1, "pipeline.batch.size"=>125, "pipeline.batch.delay"=>50, "pipeline.max_inflight"=>125, :thread=>"#<Thread:0x470bf1ca run>"} [INFO ] 2019-08-02 18:29:22.351 [[main]-pipeline-manager] javapipeline - Pipeline started {"pipeline.id"=>"main"} [INFO ] 2019-08-02 18:29:22.721 [Ruby-0-Thread-1: /usr/share/logstash/lib/bootstrap/environment.rb:6] agent - Pipelines running {:count=>1, :running_pipelines=>[:main], :non_running_pipelines=>[]} [INFO ] 2019-08-02 18:29:23.798 [Api Webserver] agent - Successfully started Logstash API endpoint {:port=>9600} /usr/share/logstash/vendor/bundle/jruby/2.5.0/gems/rufus-scheduler-3.0.9/lib/rufus/scheduler/cronline.rb:77: warning: constant ::Fixnum is deprecated /usr/share/logstash/vendor/bundle/jruby/2.5.0/gems/rufus-scheduler-3.0.9/lib/rufus/scheduler/cronline.rb:77: warning: constant ::Fixnum is deprecated /usr/share/logstash/vendor/bundle/jruby/2.5.0/gems/rufus-scheduler-3.0.9/lib/rufus/scheduler/cronline.rb:77: warning: constant ::Fixnum is deprecated [INFO ] 2019-08-02 18:30:02.333 [Ruby-0-Thread-22: /usr/share/logstash/vendor/bundle/jruby/2.5.0/gems/rufus-scheduler-3.0.9/lib/rufus/scheduler/jobs.rb:284] jdbc - (0.042932s) SELECT * FROM pg_stat_user_indexes [INFO ] 2019-08-02 18:30:02.340 [Ruby-0-Thread-23: /usr/share/logstash/vendor/bundle/jruby/2.5.0/gems/rufus-scheduler-3.0.9/lib/rufus/scheduler/jobs.rb:331] jdbc - (0.043178s) SELECT * FROM pg_stat_user_tables [INFO ] 2019-08-02 18:30:02.340 [Ruby-0-Thread-24: :1] jdbc - (0.036469s) SELECT * FROM pg_stat_database ...

      Se o Logstash não mostrar nenhum erro e registrar com êxito as linhas Selecionadas (SELECT) dos três bancos de dados, suas métricas serão enviadas ao Elasticsearch. Se você obtiver um erro, verifique todos os valores no arquivo de configuração para garantir que a máquina na qual você está executando o Logstash possa se conectar ao banco de dados gerenciado.

      O Logstash continuará importando os dados em horários especificados. Você pode pará-lo com segurança pressionando CTRL+C.

      Como mencionado anteriormente, quando iniciado como um serviço, o Logstash executa automaticamente todos os arquivos de configuração encontrados em /etc/logstash/conf.d em segundo plano. Execute o seguinte comando para iniciá-lo como um serviço:

      • sudo systemctl start logstash

      Neste passo, você executou o Logstash para verificar se ele pode se conectar ao seu banco de dados e coletar dados. Em seguida, você visualizará e explorará alguns dos dados estatísticos no Kibana.

      Passo 4 — Explorando os Dados Importados no Kibana

      Nesta seção, você verá como você pode explorar os dados estatísticos que descrevem o desempenho do seu banco de dados no Kibana.

      No seu navegador, navegue até a instalação do Kibana que você configurou como pré-requisito. Você verá a página de boas-vindas padrão.

      Kibana - Default Welcome Page

      Para interagir com os índices do Elasticsearch no Kibana, você precisará criar um padrão de índice ou Index patterns. Index patterns especificam em quais índices o Kibana deve operar. Para criar um, pressione o último ícone (chave inglesa) na barra lateral vertical esquerda para abrir a página Management. Em seguida, no menu esquerdo, clique em Index Patterns abaixo de Kibana.. Você verá uma caixa de diálogo para criar um padrão de índice.

      Kibana - Add Index Pattern

      Aqui estão listados os três índices para os quais o Logstash está enviando estatísticas. Digite pg_stat_database na caixa de entrada Index Pattern e pressione Next step. Você será solicitado a selecionar um campo que armazene tempo, para poder restringir seus dados posteriormente por um intervalo de tempo. No menu suspenso, selecione @timestamp.

      Kibana - Index Pattern Timestamp Field

      Clique em Create index pattern para concluir a criação do padrão de índice. Agora você poderá explorá-lo usando o Kibana. Para criar uma visualização, clique no segundo ícone na barra lateral e, em seguida, em Create new visualization. Selecione a visualização Line quando o formulário aparecer e escolha o padrão de índice que você acabou de criar (pg_stat_database). Você verá uma visualização vazia.

      Kibana - Empty Visualisation

      Na parte central da tela está o gráfico resultante — o painel do lado esquerdo governa sua geração a partir da qual você pode definir os dados para os eixos X e Y. No lado superior direito da tela, está o seletor de período. A menos que você escolha especificamente outro intervalo ao configurar os dados, esse intervalo será mostrado no gráfico.

      Agora você visualizará o número médio de tuplas de dados inseridas (INSERT) em minutos no intervalo especificado. Clique em Y-Axis em Metrics no painel à esquerda para expandir. Selecione Average ou média como Aggregation e selecione tup_inserted como Field ou campo. Isso preencherá o eixo Y do gráfico com os valores médios.

      Em seguida, clique em X-Axis em Buckets. Para Aggregation, escolha Date Histogram. @timestamp deve ser selecionado automaticamente como o Field. Em seguida, pressione o botão play azul na parte superior do painel para gerar seu gráfico. Se o seu banco de dados for novo e não for usado, você não verá nada ainda. Em todos os casos, no entanto, você verá um retrato preciso do uso do banco de dados.

      O Kibana suporta muitas outras formas de visualização — você pode explorar outras formas na documentação do Kibana. Você também pode adicionar os dois índices restantes, mencionados no Passo 2 ao Kibana para poder visualizá-los também.

      Neste passo, você aprendeu como visualizar alguns dos dados estatísticos do PostgreSQL, usando o Kibana.

      Passo 5 — (Opcional) Fazendo Benchmark Usando pgbench

      Se você ainda não trabalhou no seu banco de dados fora deste tutorial, você pode concluir esta etapa para criar visualizações mais interessantes usando o pgbench para fazer benchmark do seu banco de dados. O pgbench executará os mesmos comandos SQL repetidamente, simulando o uso do banco de dados no mundo real por um cliente real.

      Você primeiro precisará instalar o pgbench executando o seguinte comando:

      • sudo apt install postgresql-contrib -y

      Como o pgbench irá inserir e atualizar dados de teste, você precisará criar um banco de dados separado para ele. Para fazer isso, vá para a guia Users & Databases no Painel de Controle do seu banco de dados gerenciado e role para baixo até a seção Databases. Digite pgbench como o nome do novo banco de dados e pressione Save. Você passará esse nome, bem como as informações de host, porta e nome de usuário para o pgbench.

      Accessing Databases section in DO control panel

      Antes de executar de fato o pgbench, você precisará executá-lo com a flag -i para inicializar seu banco de dados:

      • pgbench -h host -p port -U username -i pgbench

      Você precisará substituir host pelo seu endereço de host, port pela porta à qual você pode se conectar ao seu banco de dados e username com o nome do usuário do banco de dados. Você pode encontrar todos esses valores no painel de controle do seu banco de dados gerenciado.

      Observe que o pgbench não possui um argumento de senha; em vez disso, você será solicitado sempre que executá-lo.

      A saída terá a seguinte aparência:

      Output

      NOTICE: table "pgbench_history" does not exist, skipping NOTICE: table "pgbench_tellers" does not exist, skipping NOTICE: table "pgbench_accounts" does not exist, skipping NOTICE: table "pgbench_branches" does not exist, skipping creating tables... 100000 of 100000 tuples (100%) done (elapsed 0.16 s, remaining 0.00 s) vacuum... set primary keys... done.

      O pgbench criou quatro tabelas que serão usadas para o benchmarking e as preencheu com algumas linhas de exemplo. Agora você poderá executar benchmarks.

      Os dois argumentos mais importantes que limitam por quanto tempo o benchmark será executado são -t, que especifica o número de transações a serem concluídas, e -T, que define por quantos segundos o benchmark deve ser executado. Essas duas opções são mutuamente exclusivas. No final de cada benchmark, você receberá estatísticas, como o número de transações por segundo (tps).

      Agora, inicie um benchmark que durará 30 segundos executando o seguinte comando:

      • pgbench -h host -p port -U username pgbench -T 30

      A saída será semelhante a:

      Output

      starting vacuum...end. transaction type: <builtin: TPC-B (sort of)> scaling factor: 1 query mode: simple number of clients: 1 number of threads: 1 duration: 30 s number of transactions actually processed: 7602 latency average = 3.947 ms tps = 253.382298 (including connections establishing) tps = 253.535257 (excluding connections establishing)

      Nesta saída, você vê as informações gerais sobre o benchmark, como o número total de transações executadas. O efeito desses benchmarks é que as estatísticas enviadas pelo Logstash para o Elasticsearch refletirão esse número, o que tornará as visualizações no Kibana mais interessantes e mais próximas dos gráficos do mundo real. Você pode executar o comando anterior mais algumas vezes e talvez alterar a duração.

      Quando terminar, vá para o Kibana e clique em Refresh no canto superior direito. Agora você verá uma linha diferente da anterior, que mostra o número de INSERTs. Sinta-se à vontade para alterar o intervalo de tempo dos dados mostrados, alterando os valores no seletor posicionado acima do botão de atualização. Aqui está como o gráfico pode se apresentar após vários benchmarks de duração variável:

      Kibana - Visualization After Benchmarks

      Você usou o pgbench para fazer benchmark em seu banco de dados e avaliou os gráficos resultantes no Kibana.

      Conclusão

      Agora você tem a pilha Elastic instalada em seu servidor e configurada para coletar regularmente dados estatísticos do banco de dados PostgreSQL gerenciado. Você pode analisar e visualizar os dados usando o Kibana, ou algum outro software adequado, que o ajudará a reunir informações valiosas e correlações do mundo real sobre o desempenho do seu banco de dados.

      Para obter mais informações sobre o que você pode fazer com o banco de dados gerenciado do PostgreSQL, visite a documentação de produto.



      Source link