One place for hosting & domains

      December 2018

      How To Sync and Share Your Files with Seafile on Ubuntu 18.04


      The author selected Wikimedia Foundation Inc. to receive a donation as part of the Write for DOnations program.

      Introduction

      Seafile is an open-source, self-hosted, file synchronization and sharing platform. Users can store and optionally encrypt data on their own servers with storage space as the only limitation. With Seafile you can share files and folders using cross-platform syncing and password-protected links to files with expiration dates. A file-versioning feature means that users can restore deleted and modified files or folders.

      In this tutorial you will install and configure Seafile on an Ubuntu 18.04 server. You will use MySQL to store data for the different components of Seafile, and Apache as the proxy server to handle the web traffic. After completing this tutorial you will be able use the web interface to access Seafile from desktop or mobile clients, allowing you to sync and share your files with other users or groups on the server or with the public.

      Prerequisites

      Before you begin this guide, you’ll need the following:

      • One Ubuntu 18.04 server with a minimum of 2GB of RAM set up by following this Initial Server Setup for Ubuntu 18.04 tutorial, including a sudo non-root user and a firewall.
      • An Apache web server with a virtual host configured for the registered domain by following How To Install the Apache Web Server on Ubuntu 18.04.
      • An SSL certificate installed on your server by following this How To Secure Apache with Let’s Encrypt on Ubuntu 18.04 tutorial.
      • A fully registered domain name. This tutorial will use example.com throughout.
      • Both of the following DNS records set up for your server. You can follow this introduction to DigitalOcean DNS for details on how to add them.

        • An A record with example.com pointing to your server’s public IP address.
        • An A record with www.example.com pointing to your server’s public IP address.
      • A MySQL database server installed and configured. Follow the steps in the How To Install MySQL on Ubuntu 18.04 tutorial. Skip Step 3 of this tutorial — “Adjusting User Authentication and Privileges”. You will only be making local connections to the database server, so changing the authentication method for the root user is not necessary.

      Step 1 — Creating Databases for the Seafile Components

      Seafile requires three components in order to work properly. These three components are:

      • Seahub: Seafile’s web frontend, written in Python using the Django web framework. From Seahub you can access, manage, and share your files using a web browser.
      • Seafile server: The data service daemon that manages the raw file upload, download, and synchronization. You do not interact with the server directly, but use one of the client programs or the Seahub web interface.
      • Ccnet server: The RPC service daemon to enable internal communication between the different components of Seafile. For example, when you use Seahub, it is able to access data from the Seafile server using the Ccnet RPC service.

      Each of these components stores its data separately in its own database. In this step you will create the three MySQL databases and a user before proceeding to set up the server.

      First, log in to the server using SSH with your username and IP address:

      ssh sammy@your_server_ip
      

      Connect to the MySQL database server as administrator (root):

      At the MySQL prompt, use the following SQL command to create the database user:

      • CREATE USER 'sammy'@'localhost' IDENTIFIED BY 'password';

      Next, you will create the following databases to store the data of the three Seafile components:

      • ccnet-db for the Ccnet server.
      • seahub-db for the Seahub web frontend.
      • seafile-db for the Seafile file server.

      At the MySQL prompt, create your databases:

      • CREATE DATABASE `ccnet-db` CHARACTER SET = 'utf8';
      • CREATE DATABASE `seafile-db` CHARACTER SET = 'utf8';
      • CREATE DATABASE `seahub-db` CHARACTER SET = 'utf8';

      Then, grant all privileges to the Seafile database user to access and make changes in these databases:

      • GRANT ALL PRIVILEGES ON `ccnet-db`.* to `sammy`@localhost;
      • GRANT ALL PRIVILEGES ON `seafile-db`.* to `sammy`@localhost;
      • GRANT ALL PRIVILEGES ON `seahub-db`.* to `sammy`@localhost;

      Exit the MySQL prompt by typing exit:

      Now that you have created a user and the databases required to store the data for each of the Seafile components, you will install dependencies to download the Seafile server package.

      Step 2 — Installing Dependencies and Downloading Seafile

      Some parts of Seafile are written in Python and therefore require additional Python modules and programs to work. In this step, you will install these required dependencies before downloading and extracting the Seafile server package.

      To install the dependencies using apt run the following command:

      • sudo apt install python-setuptools python-pip python-urllib3 python-requests python-mysqldb ffmpeg

      The python-setuptools and python-pip dependencies oversee installing and managing Python packages. The python-urllib3 and python-requests packages make requests to websites. Finally, the python-mysqldb is a library for using MySQL from Python and ffmpeg handles multimedia files.

      The pillow and moviepy Python modules required by Seafile are not available in the Ubuntu package repository. You will install them manually using pip:

      • sudo pip install pillow moviepy

      Seafile requires pillow, a python library for image processing, and moviepy to handle movie file thumbnails.

      NOTE: You will also need to upgrade these packages manually when new versions are released. The command to upgrade is:

      • sudo pip install --upgrade pillow moviepy

      Now that you have installed the necessary dependencies, you can download the Seafile server package.

      Seafile creates additional directories during setup. To keep them all organized, create a new directory and change into it:

      You can now download the latest version (6.3.4 as of this writing) of the Seafile server from the website by running the following command:

      • wget https://download.seadrive.org/seafile-server_6.3.4_x86-64.tar.gz

      Seafile distributes the download as a compressed tar archive, which means you will need to extract it before proceeding. Extract the archive using tar:

      • tar -zxvf seafile-server_6.3.4_x86-64.tar.gz

      Now change into the extracted directory:

      At this stage, you have downloaded and extracted the Seafile server package and have also installed the necessary dependencies. You are now ready to configure the Seafile server.

      Step 3 — Configuring the Seafile Server

      Seafile needs some information about your setup before you start the services for the first time. This includes details like the domain name, the database configuration, and the path where it will store data. To initiate the series of question prompts to provide this information, you can run the script setup_seafile_mysql.sh, which is included in the archive you extracted in the previous step.

      Run the script using bash:

      • bash setup-seafile-mysql.sh

      Press ENTER to continue.

      The script will now prompt you with a series of questions. Wherever defaults are mentioned, pressing the ENTER key will use that value.

      This tutorial uses Seafile as the server name, but you can change it if necessary.

      **Question 1**
      
          What is the name of the server?
          It will be displayed on the client. 3 - 15 letters or digits
          [ server name ] Seafile
      

      Enter the domain name for this Seafile instance.

      **Question 2**
      
          What is the ip or domain of the server?.
          For example: www.mycompany.com, 192.168.1.101
          [ This server's ip or domain ] example.com
      

      For Question 3 press ENTER to accept the default value. If you have set up external storage, for example, using NFS or block storage, you will need to specify the path to that location here instead.

      **Question 3**
      
          Where do you want to put your seafile data?
          Please use a volume with enough free space
          [ default "/home/sammy/seafile/seafile-data" ]
      

      For Question 4 press ENTER to accept the default value.

      **Question 4**
      
          Which port do you want to use for the seafile fileserver?
          [ default "8082" ]
      

      The next prompt allows you to confirm the database configuration. You can create new databases or use existing databases for setup. For this tutorial you have created the necessary databases in Step 1, so select option 2 here.

      -------------------------------------------------------
      Please choose a way to initialize seafile databases:
      -------------------------------------------------------
      
      [1] Create new ccnet/seafile/seahub databases
      [2] Use existing ccnet/seafile/seahub databases
      
      [ 1 or 2 ] 2
      

      Questions 6–9 relate to the MySQL database server. You will only need to provide the username and password of the mysql user that you created in Step 1. Press ENTER to accept the default values for host and port.

      
          What is the host of mysql server?
      
          [ default "localhost" ]
      
          What is the port of mysql server?
      
          [ default "3306" ]
      
          Which mysql user to use for seafile?
      
          [ mysql user for seafile ] sammy
      
          What is the password for mysql user "seafile"?
      
          [ password for seafile ] password
      

      After providing the password, the script will request the names of the Seafile databases. Use ccnet-db, seafile-db, and seahub-db for this tutorial. The script will then verify if there is a successful connection to the databases before proceeding to display a summary of the initial configuration.

      Enter the existing database name for ccnet:
      [ ccnet database ] ccnet-db
      
      verifying user "sammy" access to database ccnet-db ...  done
      
      Enter the existing database name for seafile:
      [ seafile database ] seafile-db
      
      verifying user "sammy" access to database seafile-db ...  done
      
      Enter the existing database name for seahub:
      [ seahub database ] seahub-db
      
      verifying user "sammy" access to database seahub-db ...  done
      
      ---------------------------------
      This is your configuration
      ---------------------------------
      
          server name:            Seafile
          server ip/domain:       example.com
      
          seafile data dir:       /home/sammy/seafile/seafile-data
          fileserver port:        8082
      
          database:               use existing
          ccnet database:         ccnet-db
          seafile database:       seafile-db
          seahub database:        seahub-db
          database user:          sammy
      
      --------------------------------
      Press ENTER to continue, or Ctrl-C to abort
      ---------------------------------
      

      Press ENTER to confirm.

      Output

      Generating ccnet configuration ... done Successly create configuration dir /home/sammy/seafile/ccnet. Generating seafile configuration ... done Generating seahub configuration ... ---------------------------------------- Now creating seahub database tables ... ---------------------------------------- creating seafile-server-latest symbolic link ... done ----------------------------------------------------------------- Your seafile server configuration has been finished successfully. ----------------------------------------------------------------- run seafile server: ./seafile.sh { start | stop | restart } run seahub server: ./seahub.sh { start <port> | stop | restart <port> } ----------------------------------------------------------------- If you are behind a firewall, remember to allow input/output of these tcp ports: ----------------------------------------------------------------- port of seafile fileserver: 8082 port of seahub: 8000 When problems occur, Refer to https://github.com/haiwen/seafile/wiki for information.

      As you will be running Seafile behind Apache, opening ports 8082 and 8000 in the firewall is not necessary, so you can ignore this part of the output.

      You have completed the initial configuration of the server. In the next step, you will configure the Apache web server before starting the Seafile services.

      Step 4 — Configuring the Apache Web Server

      In this step, you will configure the Apache web server to forward all requests to Seafile. Using Apache in this manner allows you to use a URL without a port number, enable HTTPS connections to Seafile, and make use of the caching functionality that Apache provides for better performance.

      To begin forwarding requests, you will need to enable the proxy_http module in the Apache configuration. This module provides features for proxying HTTP and HTTPS requests. The following command will enable the module:

      Note: The Apache rewrite and ssl modules are also required for this setup. You have already enabled these modules as part of configuring Let's Encrypt in the second Apache tutorial listed in the prerequisites section.

      Next, update the virtual host configuration of example.com to forward requests to the Seafile file server and to the Seahub web interface.

      Open the configuration file in a text editor:

      • sudo nano /etc/apache2/sites-enabled/example.com-le-ssl.conf

      The lines from ServerAdmin to SSLCertificateKeyFile are part of the initial Apache and Let's Encrypt configuration that you set up as part of the prerequisite. Add the highlighted content, beginning at Alias and ending with the ProxyPassReverse directive:

      /etc/apache2/sites-enabled/example.com-le-ssl.conf

      
      <IfModule mod_ssl.c>
      <VirtualHost *:443>
          ServerAdmin [email protected]
          ServerName example.com
          ServerAlias www.example.com
          DocumentRoot /var/www/example.com/html
          ErrorLog ${APACHE_LOG_DIR}/example.com-error.log
          CustomLog ${APACHE_LOG_DIR}/example.com-access.log combined
      
          Include /etc/letsencrypt/options-ssl-apache.conf
          SSLCertificateFile /etc/letsencrypt/live/example.com/fullchain.pem
          SSLCertificateKeyFile /etc/letsencrypt/live/example.com/privkey.pem
      
          Alias /media  /home/sammy/seafile/seafile-server-latest/seahub/media
          <Location /media>
              Require all granted
          </Location>
      
          # seafile fileserver
          ProxyPass /seafhttp http://127.0.0.1:8082
          ProxyPassReverse /seafhttp http://127.0.0.1:8082
          RewriteEngine On
          RewriteRule ^/seafhttp - [QSA,L]
      
          # seahub web interface
          SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
          ProxyPass / http://127.0.0.1:8000/
          ProxyPassReverse / http://127.0.0.1:8000/
      </VirtualHost>
      </IfModule>
      

      The Alias directive maps the URL path example.com/media to a local path in the file system that Seafile uses. The following Location directive enables access to content in this directory. The ProxyPass and ProxyPassReverse directives make Apache act as a reverse proxy for this host, forwarding requests to / and /seafhttp to the Seafile web interface and file server running on local host ports 8000 and 8082 respectively. The RewriteRule directive passes all requests to /seafhttp unchanged and stops processing further rules ([QSA,L]).

      Save and exit the file.

      Test if there are any syntax errors in the virtual host configuration:

      • sudo apache2ctl configtest

      If it reports Syntax OK, then there are no issues with your configuration. Restart Apache for the changes to take effect:

      • sudo systemctl restart apache2

      You have now configured Apache to act as a reverse proxy for the Seafile file server and Seahub. Next, you will update the URLs in Seafile's configuration before starting the services.

      Step 5 — Updating Seafile's Configuration and Starting Services

      As you are now using Apache to proxy all requests to Seafile, you will need to update the URLs in Seafile's configuration files in the conf directory using a text editor before you start the Seafile service.

      Open ccnet.conf in a text editor:

      • nano /home/sammy/seafile/conf/ccnet.conf

      Modify the SERVICE_URL setting in the file to point to the new HTTPS URL without the port number, for example:

      /home/sammy/seafile/conf/ccnet.conf

      SERVICE_URL = https://example.com
      

      Save and exit the file once you have added the content.

      Now open seahub_settings.py in a text editor:

      • nano /home/sammy/seafile/conf/seahub_settings.py

      You can now add a FILE_SERVER_ROOT setting in the file to specify the path where the file server is listening for file uploads and downloads:

      /home/sammy/seafile/conf/seahub_settings.py

      # -*- coding: utf-8 -*-
      SECRET_KEY = "..."
      FILE_SERVER_ROOT = 'https://example.com/seafhttp'
      # ...
      

      Save and exit seahub_settings.py.

      Now you can start the Seafile service and the Seahub interface:

      • cd /home/sammy/seafile/seafile-server-6.3.4
      • ./seafile.sh start
      • ./seahub.sh start

      As this is the first time you have started the Seahub service, it will prompt you to create an admin account. Enter a valid email address and a password for this admin user:

      Output

      What is the email for the admin account? [ admin email ] [email protected] What is the password for the admin account? [ admin password ] password-here Enter the password again: [ admin password again ] password-here ---------------------------------------- Successfully created seafile admin ---------------------------------------- Seahub is started Done.

      Open https://example.com in a web browser and log in using your Seafile admin email address and password.

      Login screen of the Seafile web interface

      Once logged in successfully, you can access the admin interface or create new users.

      Now that you have verified the web interface is working correctly, you can enable these services to start automatically at system boot in the next step.

      Step 6 — Enabling the Seafile Server to Start at System Boot

      To enable the file server and the web interface to start automatically at boot, you can create the respective systemd service files and activate them.

      Create a systemd service file for the Seafile file server:

      • sudo nano /etc/systemd/system/seafile.service

      Add the following content to the file:

      /etc/systemd/system/seafile.service

      [Unit]
      Description=Seafile
      After=network.target mysql.service
      
      [Service]
      Type=forking
      ExecStart=/home/sammy/seafile/seafile-server-latest/seafile.sh start
      ExecStop=/home/sammy/seafile/seafile-server-latest/seafile.sh stop
      User=sammy
      Group=sammy
      
      [Install]
      WantedBy=multi-user.target
      

      Here, the ExectStart and ExecStop lines indicate the commands that run to start and stop the Seafile service. The service will run with sammy as the User and Group. The After line specifies that the Seafile service will start after the networking and MySQL service has started.

      Save seafile.service and exit.

      Create a systemd service file for the Seahub web interface:

      • sudo nano /etc/systemd/system/seahub.service

      This is similar to the Seafile service. The only difference is that the web interface is started after the Seafile service. Add the following content to this file:

      /etc/systemd/system/seahub.service

      [Unit]
      Description=Seafile hub
      After=network.target seafile.service
      
      [Service]
      Type=forking
      ExecStart=/home/sammy/seafile/seafile-server-latest/seahub.sh start
      ExecStop=/home/sammy/seafile/seafile-server-latest/seahub.sh stop
      User=sammy
      Group=sammy
      
      [Install]
      WantedBy=multi-user.target
      

      Save seahub.service and exit.

      You can learn more about systemd unit files in the Understanding Systemd Units and Unit Files tutorial.

      Finally, to enable both the Seafile and Seahub services to start automatically at boot, run the following commands:

      • sudo systemctl enable seafile.service
      • sudo systemctl enable seahub.service

      When the server is rebooted, Seafile will start automatically.

      At this point, you have completed setting up the server, and can now test each of the services.

      Step 7 — Testing File Syncing and Sharing Functionality

      In this step, you will test the file synchronization and sharing functionality of the server you have set up and ensure they are working correctly. To do this, you will need to install the Seafile client program on a separate computer and/or a mobile device.

      Visit the download page on the Seafile website and follow the instructions to install the latest version of the program on your computer. Seafile clients are available for the various distributions of Linux (Ubuntu, Debian, Fedora, Centos/RHEL, Arch Linux), MacOS, and Windows. Mobile clients are available for Android and iPhone/iPad devices from the respective app stores.

      Once you have installed the Seafile client, you can test the file synchronization and sharing functionality.

      Open the Seafile client program on your computer or device. Accept the default location for the Seafile folder and click Next.

      In the next window, enter the server address, username, and password, then click Login.

      At the home page, right click on My Library and click Sync this library. Accept the default value for the location on your computer or device.

      Seafile client — Sync the default library

      Add a file, for example a document or a photo, into the My Library folder. After some time, the file will upload to the server. The following screenshot shows the file photo.jpg copied to the My Library folder.

      Add a file to the default library from the computer

      Now, log in to the web interface at https://example.com and verify that your file is present on the server.

      My Library page to verify file sync

      Click on Share next to the file to generate a download link for this file that you can share.

      You have verified that the file synchronization is working correctly and that you can use Seafile to sync and share files and folders from multiple devices.

      Conclusion

      In this tutorial you set up a private instance of a Seafile server. Now you can start using the server to synchronize files, add users and groups, and share files between them or with the public without relying on an external service.

      When a new release of the server is available, please consult the upgrade section of the manual for steps to perform an upgrade.



      Source link

      Como Solucionar Problemas no MySQL


      Introdução

      O MySQL é um sistema gerenciador de banco de dados relacional open-source, o mais popular de seu tipo no mundo. Como é comum quando se trabalha com qualquer software, tanto os novatos quanto os usuários experientes podem encontrar mensagens de erro confusas ou problemas difíceis de diagnosticar.

      Este guia servirá como um recurso de solução de problemas e um ponto de partida à medida que você diagnostica sua configuração do MySQL. Analisaremos alguns dos problemas que muitos usuários do MySQL encontram e forneceremos orientações para solucionar problemas específicos. Também incluiremos links para tutoriais da DigitalOcean e a documentação oficial do MySQL que pode ser útil em certos casos.

      Por favor, observe que este guia assume a configuração descrita em Como Instalar o MySQL no Ubuntu 18.04, e os tutoriais vinculados em todo o guia refletem essa configuração. Se seu servidor estiver executando outra distribuição, contudo, você pode encontrar um guia específico para essa distro no Menu de Versão do tutorial, na parte superior dos tutoriais vinculados, quando houver um disponível.

      O lugar onde muitos usuários iniciantes do MySQL se deparam com problemas é durante o processo de instalação e configuração. Nosso guia sobre Como Instalar o MySQL no Ubuntu 18.04 fornece instruções sobre como configurar uma instalação básica e pode ser útil para aqueles que são novos no MySQL.

      Outra razão pela qual alguns usuários enfrentam problemas é que seu aplicativo requer recursos de banco de dados que estão presentes apenas nas últimas versões, mas a versão do MySQL disponível nos repositórios padrão de algumas distribuições Linux — incluindo o Ubuntu — não é a última versão. Por esta razão, os desenvolvedores MySQL mantém seus próprios repositórios de software, que você pode utilizar para instalar a versão mais recente e mantê-la atualizada. Nosso tutorial “How To Install the Latest MySQL on Ubuntu 18.04” fornece instruções sobre como fazer isso.

      Como Acessar os Logs de Erros do MySQL

      Muitas vezes, a causa raiz de lentidão, falha ou outro comportamento inesperado no MySQL pode ser determinada pela análise de seus logs de erro. Em sistemas Ubuntu, a localização padrão para o MySQL é em /var/log/mysql/error.log. Em muitos casos, os logs de erros são lidos mais facilmente com o programa less, um utilitário de linha de comando que lhe permite ver arquivos mas não editá-los:

      • sudo less /var/log/mysql/error.log

      Se o MySQL não estiver se comportando como esperado, você pode obter mais informações sobre a origem do problema executando este comando e diagnosticando o erro com base no conteúdo do log.

      Redefinindo a Senha do Usuário root do MySQL

      Se você tiver definido uma senha para o usuário root da sua instalação do MySQL, mas se equeceu dela, você poderia ficar bloqueado para acesso aos seus bancos de dados. Contanto que você tenha acesso ao servidor no qual seu banco de dados está hospedado, contudo, você deverá ser capaz de redefini-la.

      Esse processo é diferente de redefinir a senha para um nome de usuário padrão do Linux. Verifique nosso guia How To Reset Your MySQL or MariaDB Root Password para ler e entender esse processo.

      Às vezes, os usuários enfrentam problemas quando começam a realizar consultas nos dados. Em alguns sistemas de banco de dados, incluindo o MySQL, os comandos de consulta devem terminar com um ponto-e-vírgula (;) para que sejam completados, como no seguinte exemplo:

      • SHOW * FROM nome_da_tabela;

      Se você não incluir um ponto-e-vírgula no final de sua consulta, o prompt continuará em uma nova linha até que você complete a consulta inserindo um ponto-e-vírgula e pressionando ENTER.

      Alguns usuários podem achar que suas consultas estão extremamente lentas. Uma maneira de descobrir qual comando de consulta é a causa de uma lentidão é ativar e visualizar o log de consultas lentas do MySQL. Para fazer isso, abra o seu arquivo mysqld.cnf, que é utilizado para configurar opções para o servidor do MySQL. Este arquivo é normalmente armazenado dentro do diretório /etc/mysql/mysql.conf.d/:

      • sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

      Percorra o arquivo até ver as seguintes linhas:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      #slow_query_log         = 1
      #slow_query_log_file    = /var/log/mysql/mysql-slow.log
      #long_query_time = 2
      #log-queries-not-using-indexes
      . . .
      

      Essas diretivas comentadas fornecem as opções padrão de configuração do MySQL para o log de consultas lentas. Especificamente, aqui está o que cada uma delas faz:

      • slow-query-log: Definir isso como 1 ativa o log de consultas lentas.

      • slow-query-log-file: Isso define o arquivo onde o MySQL registrará qualquer consulta lenta. Neste caso, ele aponta para o arquivo /var/log/mysql-slow.log.

      • long_query_time: Definindo essa diretiva para 2, configura o MySQL para registrar quaisquer consultas que demorem mais de 2 segundos para serem concluídas.

      • log_queries_not_using_indexes: Isso diz ao MySQL para registrar também quaisquer consultas que executem sem índices para o arquivo /var/log/mysql-slow.log. Essa configuração não é necessária para o log de consultas lentas funcionar, mas pode ser útil para detectar consultas ineficientes.

      Descomente cada uma dessas linhas removendo os sinais de cerquilha no início. A seção ficará assim agora:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      slow_query_log = 1
      slow_query_log_file = /var/log/mysql-slow.log
      long_query_time = 2
      log_queries_not_using_indexes
      . . .
      

      Nota: Se você estiver executando o MySQL 8+, estas linhas comentadas não estarão no arquivo mysqld.cnf por padrão. Nesse caso, adicione as seguintes linhas à parte inferior do arquivo:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      slow_query_log = 1
      slow_query_log_file = /var/log/mysql-slow.log
      long_query_time = 2
      log_queries_not_using_indexes
      

      Depois de habilitar o log de consultas lentas, salve e feche o arquivo. Em seguida, reinicie o serviço MySQL:

      • sudo systemctl restart mysql

      Com essas configurações valendo, você pode encontrar comandos de consulta problemáticos visualizando o log de consultas lentas. Você pode fazer isso com o less, assim:

      • sudo less /var/log/mysql_slow.log

      Depois de encontrar as consultas que causam a lentidão, você pode verificar nosso guia How To Optimize Queries and Tables in MySQL and MariaDB on a VPS que pode ser útil para otimizá-las.

      Além disso, o MySQL inclui o comando EXPLAIN, que fornece informações sobre como o MySQL executa consultas. Esta página da documentação oficial do MySQL fornece dicas sobre como usar o EXPLAIN para destacar consultas ineficientes.

      Para obter ajuda na compreensão das estruturas básicas de consulta, consulte nosso tutorial Introduction to MySQL Queries.

      Permitindo o Acesso Remoto

      Muitos sites e aplicativos começam com o servidor da web e o back-end de banco de dados hospedado na mesma máquina. Com o tempo, no entanto, uma configuração como essa pode se tornar incômoda e difícil de escalar. Uma solução comum é separar essas funções configurando um banco de dados remoto, permitindo que o servidor e o banco de dados cresçam em seu próprio ritmo em suas próprias máquinas. Um dos problemas mais comuns que os usuários enfrentam ao tentar configurar um banco de dados MySQL remoto é que sua instância do MySQL é configurada para escutar apenas conexões locais. Este é o padrão de configuração do MySQL, mas não funcionará para uma configuração de banco de dados remota, já que o MySQL deve ser capaz de escutar por um endereço IP externo onde o servidor possa ser alcançado. Para ativar isso, abra o seu arquivo mysqld.cnf:

      • sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

      Navegue até a linha que começa com a diretiva bind-address. Será parecido com isto:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      lc-messages-dir = /usr/share/mysql
      skip-external-locking
      #
      # Instead of skip-networking the default is now to listen only on
      # localhost which is more compatible and is not less secure.
      bind-address            = 127.0.0.1
      . . .
      

      Por padrão, este valor está definido para 127.0.0.1, significando que o servidor olhará somente para conexões locais. Você precisará alterar esta diretiva para referenciar um endereço IP externo. Para fins de solução de problemas, você pode definir essa diretiva como um endereço IP curinga, seja *, ::, ou 0.0.0.0:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      lc-messages-dir = /usr/share/mysql
      skip-external-locking
      #
      # Instead of skip-networking the default is now to listen only on
      # localhost which is more compatible and is not less secure.
      bind-address            = 0.0.0.0
      . . .
      

      Nota: Se você estiver executando o MySQL 8+, a diretiva bind-address não estará no arquivo mysqld.cnf por padrão. Nesse caso, adicione a seguinte linha destacada à parte inferior do arquivo:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      [mysqld]
      pid-file        = /var/run/mysqld/mysqld.pid
      socket          = /var/run/mysqld/mysqld.sock
      datadir         = /var/lib/mysql
      log-error       = /var/log/mysql/error.log
      bind-address            = 0.0.0.0
      

      Depois de alterar esta linha, salve e feche o arquivo e em seguida, reinicie o serviço MySQL:

      • sudo systemctl restart mysql

      Depois disso, tente acessar seu banco de dados remotamente a partir de outra máquina:

      • mysql -u usuário -h ip_servidor_de_banco_de_dados -p

      Se você for capaz de acessar seu banco de dados, isso confirma que a diretiva bind-address em seu arquivo de configuração era o problema. Por favor, observe, entretanto, que a configuração de bind-address para0.0.0.0 é insegura, pois permite conexões ao seu servidor a partir de qualquer endereço IP. Por outro lado, se você ainda não conseguir acessar o banco de dados remotamente, algo mais pode estar causando o problema. Em ambos os casos, você pode achar útil seguir nosso guia How To Set Up a Remote Database to Optimize Site Performance with MySQL on Ubuntu 18.04 para definir uma configuração de banco de dados remota mais segura.

      O MySQL Pára Inesperadamente ou Falha ao Iniciar

      A causa mais comum de falhas no MySQL é que ele parou ou falhou ao iniciar devido a memória insuficiente. Para verificar isso, você precisará revisar o log de erros do MySQL após uma falha.

      Primeiro, tente iniciar o servidor MySQL digitando:

      • sudo systemctl start mysql

      Em seguida, revise os logs de erro para ver o que está causando o travamento do MySQL. Você pode usar o less para revisar seus logs, uma página por vez:

      • sudo less /var/log/mysql/error.log

      Algumas mensagens comuns que indicariam uma quantidade insuficiente de memória são Out of memory ou mmap can't allocate.

      Soluções potenciais para uma quantidade inadequada de memória são:

      • Otimização da sua configuração do MySQL. Uma ótima ferramenta open-source para isso é o MySQLtuner. A execução do script MySQLtuner irá gerar um conjunto de ajustes recomendados para o seu arquivo de configuração do MySQL (mysqld.cnf). Observe que quanto mais tempo seu servidor estiver rodando antes de usar o MySQLTuner, mais precisas serão as suas sugestões. Para obter uma estimativa de uso de memória das configurações atuais e as propostas pelo MySQLTimer, use esta Calculadora MySQL.

      • Redução da confiança da sua aplicação web no MySQL para carregamentos de página. Isso geralmente pode ser feito adicionando-se cache estático à sua aplicação. Exemplos disso incluem o Joomla, que tem o cache como um recurso interno que pode ser ativado, e o WP Super Cache, um plugin do WordPress que adiciona esse tipo de funcionalidade.

      • Atualização para um VPS maior. No mínimo, recomendamos um servidor com pelo menos 1 GB de RAM para qualquer servidor que use um banco de dados MySQL, mas o tamanho e o tipo dos dados podem afetar significativamente os requisitos de memória.

      Lembre-se de que, embora a atualização do seu servidor seja uma solução em potencial, ela só é recomendável depois que você investigar e pesar todas as outras opções. Um servidor atualizado com mais recursos também vai custar mais dinheiro, então você só deve redimensionar se realmente isso acabar sendo sua melhor opção. Observe também que a documentação do MySQL inclui várias outras sugestões para diagnosticar e prevenir falhas.

      Tabelas Corrompidas

      Ocasionalmente, as tabelas do MySQL podem ficar corrompidas, o que significa que ocorreu um erro e os dados contidos nelas não podem ser lidos. Tentativas de ler uma tabela corrompida geralmente levam à falha do servidor.

      Algumas causas comuns de tabelas corrompidas são:

      • O servidor MySQL parou no meio de uma escrita.

      • Um programa externo modifica uma tabela que está sendo modificada simultaneamente pelo servidor.

      • A máquina foi desligada inesperadamente.

      • O hardware do computador falhou.

      • Há um bug de software em algum lugar no código do MySQL.

      Se você suspeitar que uma de suas tabelas foi corrompida, faça um backup do diretório de dados antes de solucionar problemas ou de tentar consertar a tabela. Isso ajudará a minimizar o risco de perda de dados.

      Primeiro, pare o serviço MySQL:

      • sudo systemctl stop mysql

      Em seguida, copie todos os seus dados em um novo diretório de backup. Nos sistemas Ubuntu, o diretório de dados padrão é /var/lib/mysql/:

      • cp -r /var/lib/mysql /var/lib/mysql_bkp

      Depois de fazer o backup, você está pronto para começar a investigar se a tabela está de fato corrompida. Se a tabela utiliza o mecanismo de armazenamento MyISAM, você pode verificar se ela está corrompida executando um comando CHECK TABLE no prompt do MySQL:

      • CHECK TABLE nome_da_tabela;

      Uma mensagem aparecerá na saída desse comando informando se ela está corrompida ou não. Se a tabela MyISAM estiver realmente corrompida, ela geralmente pode ser reparada emitindo um comando REPAIR TABLE:

      • REPAIR TABLE nome_da_tabela;

      Supondo que o reparo foi bem sucedido, você verá uma mensagem como a seguinte em sua saída:

      Output

      +---------------------------------------+--------+----------+----------+ | Table | Op | Msg_type | Msg_text | +---------------------------------------+--------+----------+----------+ | nome_do_banco_de_dados.nome_da_tabela | repair | status | OK | +---------------------------------------+--------+----------+----------+

      Se a tabela ainda estiver corrompida, a documentação do MySQL sugere alguns métodos alternativos para reparar tabelas corrompidas.

      Por outro lado, se a tabela corrompida usa o mecanismo de armazenamento InnoDB, então o processo para repará-la será diferente. O InnoDB é o mecanismo de armazenamento padrão no MySQL a partir da versão 5.5, e possui operações automatizadas de verificação e reparo de corrupção. O InnoDB verifica páginas corrompidas executando somas de verificação ou checksums em cada página que lê, e se encontrar uma discrepância no checksum, ele irá parar automaticamente o servidor MySQL.

      Raramente é necessário reparar tabelas InnoDB, já que o InnoDB possui um mecanismo de recuperação de falhas que pode resolver a maioria dos problemas quando o servidor é reiniciado. No entanto, se você encontrar uma situação onde você precisa reconstruir uma tabela InnoDB corrompida, a documentação do MySQL recomenda o método “Dump and Reload”. Isso envolve recuperar o acesso à tabela corrompida, usando o utilitário mysqldump para criar um backup lógico da tabela, que manterá a estrutura da tabela e os dados dentro dela e, em seguida, recarregar a tabela de volta no banco de dados.

      Com isso em mente, tente reiniciar o serviço MySQL para ver se isso permitirá o acesso ao servidor:

      • sudo systemctl restart mysql

      Se o servidor permanecer travado ou inacessível, então pode ser útil ativar a opção force_recovery do InnoDB. Você pode fazer isso editando o arquivo mysqld.cnf:

      • sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

      Na seção [mysqld], adicione a seguinte linha:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      
      . . .
      [mysqld]
      . . .
      innodb_force_recovery=1
      

      Salve e feche o arquivo, e então tente reiniciar o serviço MySQL novamente. Se você conseguir acessar com sucesso a tabela corrompida, use o utilitário mysqldump para descarregar os dados da sua tabela para um novo arquivo. Você pode nomear este arquivo como quiser, mas aqui nós o nomearemos como out.sql:

      • mysqldump nome_do_bando_de_dados nome_da_tabela > out.sql

      Em seguida, elimine a tabela do banco de dados. Para evitar ter que reabrir o prompt do MySQL, você pode usar a seguinte sintaxe:

      • mysql -u usuário -p --execute="DROP TABLE nome_do_banco_de_dados.nome_da_tabela"

      Depois disso, restaure a tabela com o arquivo de dump que você acabou de criar:

      • mysql -u usuário -p < out.sql

      Observe que o mecanismo de armazenamento InnoDB geralmente é mais tolerante a falhas do que o antigo mecanismo MyISAM. As tabelas que usam o InnoDB ainda podem ser corrompidas, mas devido a seus recursos de recuperação automática o risco de corrupção da tabela e falhas é decididamente menor.

      Erros de Soquete

      O MySQL gerencia conexões com o servidor de banco de dados através do uso de um arquivo de soquete, um tipo especial de arquivo que facilita a comunicação entre diferentes processos. O arquivo de soquete do servidor MySQL é chamado mysqld.sock e nos sistemas Ubuntu ele é normalmente armazenado no diretório /var/run/mysqld/. Este arquivo é criado automaticamente pelo serviço MySQL.

      Às vezes, alterações no sistema ou na configuração do MySQL podem fazer com que o MySQL não consiga ler o arquivo de soquete, impedindo o acesso aos seus bancos de dados. O erro de soquete mais comum é semelhante ao seguinte:

      Output

      ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2)

      Existem algumas razões pelas quais esse erro pode ocorrer e algumas maneiras possíveis de resolvê-lo.

      Uma causa comum desse erro é que o serviço MySQL está parado ou não iniciou, o que significa que não foi possível criar o arquivo de soquete em um primeiro momento. Para descobrir se este é o motivo pelo qual você está vendo este erro, tente iniciar o serviço com systemctl:

      • sudo systemctl start mysql

      Em seguida, tente acessar o prompt do MySQL novamente. Se você ainda receber o erro de soquete, verifique novamente o local onde sua instalação do MySQL está procurando pelo arquivo de soquete. Esta informação pode ser encontrada no arquivo mysqld.cnf:

      • sudo nano /etc/mysql/mysql.conf.d/mysql.cnf

      Procure o parâmetro socket na seção[mysqld] deste arquivo. Isso parecerá assim:

      /etc/mysql/mysql.conf.d/mysqld.cnf

      . . . [mysqld] user = mysql pid-file = /var/run/mysqld/mysqld.pid socket = /var/run/mysqld/mysqld.sock port = 3306 . . .

      Feche este arquivo, então certifique-se de que o arquivo mysqld.sock exista executando um comando ls no diretório onde o MySQL espera encontrá-lo:

      Se o arquivo de soquete existir, você o verá na saída deste comando:

      Output

      . .. mysqld.pid mysqld.sock mysqld.sock.lock

      Se o arquivo não existir, o motivo pode ser que o MySQL está tentando criá-lo, mas não possui permissões adequadas para isso. Você pode garantir que as permissões corretas estão em vigor, alterando a propriedade do diretório para o usuário e grupo mysql:

      • sudo chown mysql:mysql /var/run/mysqld/

      Em seguida, certifique-se de que o usuário mysql tenha as permissões apropriadas sobre o diretório. Definindo-as para 755 vai funcionar na maioria dos casos:

      • sudo chmod -R 755 /var/run/mysqld/

      Finalmente, reinicie o serviço MySQL para que ele possa tentar criar o arquivo de soquete novamente:

      • sudo systemctl restart mysql

      Em seguida, tente acessar o prompt do MySQL mais uma vez. Se você ainda encontrar o erro de soquete, provavelmente há um problema mais profundo com a sua instância do MySQL; nesse caso, você deve revisar o log de erros para ver se ele pode fornecer alguma pista.

      Conclusão

      O MySQL serve como o backbone de inúmeros aplicativos e sites orientados a dados. Com tantos casos de uso, há também tantas possíveis causas de erros. Da mesma forma, também há muitas maneiras diferentes de resolver tais erros. Neste guia, cobrimos alguns dos erros mais frequentemente encontrados, mas há muitos mais que podem surgir dependendo de como o seu aplicativo funciona com o MySQL.

      Se você não conseguiu encontrar uma solução para o seu problema específico, esperamos que este guia lhe tenha dado, pelo menos, algum conhecimento sobre solução de problemas do MySQL e o ajude a encontrar a fonte dos seus erros. Para mais informações, você pode ver a documentação oficial do MySQL, que abrange os tópicos que discutimos aqui, bem como outras estratégias de solução de problemas.

      Além disso, se o seu banco de dados MySQL estiver hospedado em um Droplet da DigitalOcean, você pode contatar nossa equipe de Suporte para obter mais assistência.

      Por Mark Drake



      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: [email protected] 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