Wie installiere ich PostgreSQL und pgAdmin auf Ubuntu 22.04
PostgreSQL oder Postgres ist eine objektrelationale Open-Source-Datenbankverwaltung, die die Abfragesprache SQL implementiert. Es verfügt über fortschrittliche Funktionen wie zuverlässige Transaktionen und Gleichzeitigkeit ohne Lesesperren, die es uns ermöglichen, fehlertolerante Umgebungen und komplexe Anwendungen aufzubauen.
pgAdmin ist ein Open-Source-Verwaltungstool für PostgreSQL. Es unterstützt mehrere Plattformen, darunter Windows, macOS und Linux.
In diesem Lernprogramm lernst du, wie du PostgreSQL 14 und pgAdmin 4 auf einem Ubuntu 22.04 Server installierst.
Voraussetzungen
- Ein Server, auf dem Ubuntu 20.04 läuft.
- Ein nicht-root sudo Benutzer.
- Ein vollständig qualifizierter Domainname (FQDN) wie
pgadmin.example.com. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update $ sudo apt upgrade
- Dein System braucht ein paar Pakete.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – PostgreSQL installieren
Ubuntu 22.04 wird standardmäßig mit PostgreSQL 14 ausgeliefert. Zur Installation gibst du den folgenden Befehl ein.
$ sudo apt install postgresql postgresql-contrib
Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.
Du kannst auch das offizielle APT-Repository von PostgreSQL für die Installation verwenden. Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Füge das APT-Repository zu deiner Quellenliste hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Aktualisiere das System-Repository.
$ sudo apt update
Jetzt kannst du PostgreSQL mit dem oben genannten Befehl installieren.
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2022-05-16 11:20:35 UTC; 5 days ago
Process: 30544 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
Main PID: 30544 (code=exited, status=0/SUCCESS)
CPU: 2ms
May 16 11:20:35 postgresql systemd[1]: Starting PostgreSQL RDBMS...
May 16 11:20:35 postgresql systemd[1]: Finished PostgreSQL RDBMS.
Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.
Schritt 2 – PostgreSQL-Rollen und Authentifizierungsmethoden verwenden
PostgreSQL verwendet ein Konzept namens Rollen, um die Authentifizierung und den Datenbankzugriff zu verwalten. Eine Rolle repräsentiert einen Benutzer oder eine Gruppe von Benutzern. Postgres unterscheidet nicht zwischen Benutzern und Gruppen.
Postgres unterstützt mehrere Authentifizierungsmethoden, z. B. die folgenden
- Vertrauen – erlaubt die Verbindung ohne Passwort, solange die in der Konfigurationsdatei festgelegten Bedingungen erfüllt sind.
- Passwort – Dies ist selbsterklärend und erfordert ein Passwort für den Zugang.
- Ident – diese Methode wird nur bei TCP/IP-Verbindungen unterstützt und ist für Fernverbindungen nützlich.
- Peer – wie Ident, wird aber nur für lokale Verbindungen verwendet.
Bei der Installation von Postgres wird standardmäßig die Peer-Authentifizierungsmethode verwendet. Bei dieser Methode wird eine Postgres-Rolle mit einem passenden Linux-Systemkonto verknüpft. Wenn eine Rolle existiert, kannst du dich mit einem Linux-Konto mit demselben Benutzernamen anmelden.
Bei der PostgreSQL-Installation wird ein Benutzerkonto postgres erstellt, das mit der Standardrolle verknüpft ist. Du kannst mit folgendem Befehl zum Konto postgres auf deinem System wechseln.
$ sudo -i -u postgres
Greife auf die PostgreSQL-Shell zu, indem du den Befehl psql verwendest.
postgres@howtoforge:~$ psql
Du wirst in die PostgreSQL-Shell eingeloggt.
psql (14.3 (Ubuntu 14.3-1.pgdg22.04+1)) Type "help" for help. postgres=#
Gib exit oder \q ein, um die Shell zu schließen.
Du kannst die PostgreSQL-Shell auch mit einem einzigen Befehl aufrufen. Der folgende Befehl führt die Shell unter dem Konto postgres aus. Wenn du die Shell beendest, wechselst du zu deinem aktuellen Systembenutzer.
$ sudo -u postgres psql
Schritt 3 – Eine neue Rolle erstellen
Du kannst neue Rollen mit dem Befehl createuser oder über die Shell psql erstellen. Um den Befehl createuser zu verwenden, musst du mit dem Konto postgres eingeloggt sein. Wenn du in Postgres eingeloggt bist, führe den folgenden Befehl aus, um eine neue Rolle zu erstellen.
postgres@howtoforge:~$ createuser --interactive
Mit dem Flag --interactive wirst du nach dem Namen der Rolle gefragt und ob sie Superuser-Rechte haben soll.
Du kannst den Befehl auch direkt von deinem Konto aus ausführen.
$ sudo -u postgres createuser --interactive
Du erhältst dann die folgende Ausgabe.
Enter name of role to add: navjot Shall the new role be a superuser? (y/n) y
Um die Rolle von der Shell psql aus zu erstellen, verwende den folgenden Befehl, sobald du dich in der Shell befindest.
postgres-# CREATE ROLE username WITH SUPERUSER CREATEDB CREATEROLE LOGIN ENCRYPTED PASSWORD 'yourpassword';
Hier erstellen wir eine Rolle mit den Berechtigungen Superuser, Datenbank erstellen, Rolle erstellen und Login.
Du kannst die Liste aller Benutzer mit dem Befehl \du überprüfen.
postgres-# \du
List of roles
Role name | Attributes | Member of
-----------+------------------------------------------------------------+-----------
username | Superuser, Create role, Create DB | {}
postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
Schritt 4 – Eine Datenbank erstellen
Um eine Datenbank zu erstellen, verwenden wir den Befehl createdb. Wenn du mit dem Konto postgres eingeloggt bist, führe den folgenden Befehl aus, um eine neue Datenbank zu erstellen.
postgres@howtoforge:~$ createdb howtoforge
Du kannst den Befehl auch von deinem Konto aus ausführen.
$ sudo -u postgres createdb howtoforge
Du kannst die Datenbank auch über die Shell psql erstellen. Dazu führst du den folgenden Befehl in der Shell aus.
postgres-# CREATE DATABASE howtoforge;
Wir können dem Benutzer, den wir gerade erstellt haben, Rechte für die Datenbank erteilen, indem wir den folgenden Befehl ausführen.
postgres-# GRANT ALL PRIVILEGES ON DATABASE howtoforge TO username;
Du kannst die Liste aller Datenbanken mit dem Befehl \l überprüfen.
postgres-# \l
List of databases
Name | Owner | Encoding | Collate | Ctype | Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
howtoforge| postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =Tc/postgres +
| | | | | postgres=CTc/postgres+
| | | | | username=CTc/postgres
postgres | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 |
template0 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
template1 | postgres | UTF8 | en_US.UTF-8 | en_US.UTF-8 | =c/postgres +
| | | | | postgres=CTc/postgres
(4 rows)
Schritt 5 – Aktiviere den Fernzugriff
Standardmäßig lauscht der PostgreSQL-Server nur auf der localhost-Schnittstelle. Um den Fernzugriff zu aktivieren, öffne die Datei /etc/postgresql/14/main/postgresql.conf und ändere die Zeile #listen_addresses = 'localhost', indem du sie auskommentierst und wie unten gezeigt im Abschnitt CONNECTIONS und AUTHENTICATION änderst.
#------------------------------------------------------------------------------ # CONNECTIONS AND AUTHENTICATION #------------------------------------------------------------------------------ # - Connection Settings - listen_addresses = '*' # what IP address(es) to listen on;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den PostgreSQL-Dienst neu.
$ sudo systemctl restart postgresql
Um die Änderung zu überprüfen, führe den folgenden Befehl aus.
$ ss -nlt | grep 5432
Du erhältst die folgende Ausgabe, die zeigt, dass PostgreSQL auf allen Schnittstellen lauscht.
LISTEN 0 244 0.0.0.0:5432 0.0.0.0:* LISTEN 0 244 [::]:5432 [::]:*
Der nächste Schritt besteht darin, den Server so zu konfigurieren, dass er Remote-Verbindungen akzeptiert. Dies geschieht durch die Bearbeitung der Datei /etc/postgresql/14/main/pg_hba.conf. Öffne die Datei zur Bearbeitung.
$ sudo nano /etc/postgresql14/main/pg_hba.conf
Hier kannst du den Zugriff auf einzelne oder alle Datenbanken konfigurieren und festlegen, welche Benutzer über welche Schnittstellen auf sie zugreifen können. Damit die Passwortauthentifizierung funktioniert, wähle scram-sha-256 als Authentifizierungsmethode. Hier sind einige Beispiele, die du verwenden kannst.
# TYPE DATABASE USER ADDRESS METHOD # The username can access all databases from all locations using scram-sha256 password host all username 0.0.0.0/0 scram-sha256 # The username can access only the howtoforge from all locations using scram-sha256 password host howtoforge username 0.0.0.0/0 scram-sha256 # The username can access all databases from a trusted location (192.168.1.134) without a password host all username 192.168.1.134 trust
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Es gibt noch einen letzten Schritt, bevor der Fernzugriff funktionieren kann. Du musst den Firewall-Port 5432 öffnen. Führe den folgenden Befehl aus, um den Port zu öffnen.
$ sudo ufw allow 5432/tcp
Dadurch kann jede IP-Adresse auf PostgreSQL zugreifen. Du solltest ihn jedoch auf vertrauenswürdige IP-Bereiche beschränken. Führe dazu stattdessen den folgenden Befehl aus. Der folgende Befehl erlaubt den Zugriff auf PostgreSQL aus dem Subnetz 192.168.1.0/24.
$ sudo ufw allow proto tcp from 192.168.1.0/24 to any port 5432
Schritt 6 – Installiere pgAdmin 4
pgAdmin kann entweder als Ubuntu-Paket oder mit Python installiert werden. Wenn du es als Ubuntu-Paket installierst, wird standardmäßig der Apache-Server installiert. Für unseren Lehrgang werden wir jedoch Nginx verwenden. Deshalb werden wir ihn mit dem Python-Rad installieren.
Erstelle die Verzeichnisse data und log für pgAdmin.
$ sudo mkdir /var/lib/pgadmin $ sudo mkdir /var/log/pgadmin
Erstelle einen app-Ordner für pgAdmin.
$ sudo mkdir /opt/pgadmin
Wechsle zum Benutzer root.
$ sudo su -
Installiere zunächst einige wichtige Pakete, die von Python benötigt werden.
$ apt install build-essential python3-dev python3-venv python3-pip
Erstelle eine virtuelle Python-Umgebung und aktiviere sie.
$ python3 -m venv /opt/pgadmin/venv $ source /opt/pgadmin/venv/bin/activate
Installiere pgAdmin und uWSGI.
(venv) root@postgresql:-$ pip install --upgrade pip (venv) root@postgresql:-$ pip install --upgrade setuptools (venv) root@postgresql:-$ pip install wheel (venv) root@postgresql:-$ pip install pgadmin4 (venv) root@postgresql:-$ pip install uwsgi
Führe die Setup-Datei von pgAdmin aus. Überprüfe den Pfad. Ubuntu 22.04 wird standardmäßig mit Python 3.10 ausgeliefert und daher ist es im Pfad sichtbar. Vergewissere dich, dass du den richtigen Pfad wählst.
(venv) root@postgresql:-$ python3 /opt/pgadmin/venv/lib/python3.10/site-packages/pgadmin4/setup.py
Folge den Installationsanweisungen und notiere dir hier deine E-Mail und dein Passwort.
NOTE: Configuring authentication for SERVER mode. Enter the email address and password to use for the initial pgAdmin user account: Email address: pgadmin@example.com Password: Retype password: pgAdmin 4 - Application Initialisation ======================================
Deaktiviere die virtuelle Umgebung.
(venv) root@postgresql:-$ deactivate
Wechsle wieder zum normalen Benutzer.
(venv) root@postgresql:-$ exit
Erstelle einen neuen Systembenutzer pgadmin. Er wird verwendet, um die pgAdmin-Prozesse auszuführen.
$ sudo adduser --system --group --home /var/lib/pgadmin --disabled-login --shell /usr/sbin/nologin pgadmin
Da wir Nginx verwenden werden, gib ihm zusammen mit dem neu angelegten Benutzer die Rechte an den oben genannten Verzeichnissen.
$ sudo chown -R pgadmin:nginx /var/lib/pgadmin /var/log/pgadmin /opt/pgadmin
Schritt 7 – Integration von uWSGI und pgAdmin
Der nächste Schritt besteht darin, einen WSGI-Server zu erstellen, der am UNIX-Socket /tmp/pgadmin.sock lauscht. Erstelle eine uWSGI-Konfigurationsdatei namens pgadmin-uwsgi.ini im Ordner /opt/pgadmin.
$ sudo nano /opt/pgadmin/pgadmin-uwsgi.ini
Füge den folgenden Code hinzu. Achte darauf, dass die Python-Version im Pfad mit der in deinem System installierten Version übereinstimmt.
[uwsgi] socket = /var/lib/pgadmin/pgadmin4.sock chdir = /opt/pgadmin/venv/lib/python3.10/site-packages/pgadmin4/ module = pgAdmin4:application threads = 20 processes = 1 mount = /=pgAdmin4:app manage-script-name = true chmod-socket = 660
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 8 – Erstellen der Servicedatei
Jetzt, wo wir pgAdmin und uWSGI konfiguriert haben, müssen wir eine systemd-Service-Unit-Datei für sie erstellen. Die Servicedatei ermöglicht es dem Server, beim Booten automatisch uWSGI zu starten und die pgAdmin 4 Anwendung zu bedienen.
Erstelle und öffne die Servicedatei zum Bearbeiten.
$ sudo nano /etc/systemd/system/pgadmin-uwsgi.service
Füge den folgenden Code in die Datei ein.
[Unit] Description=pgadmin4 on uWSGI Requires=network.target After=network.target [Service] User=pgadmin Group=nginx Environment="PATH=/opt/pgadmin/venv/bin" ExecStart=/opt/pgadmin/venv/bin/uwsgi --ini /opt/pgadmin/pgadmin-uwsgi.ini [Install] WantedBy=multi-user.target
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wie du siehst, haben wir nginx als Gruppe ausgewählt, die den pgAdmin-Prozess ausführt, da wir sie für das Proxying verwenden werden.
Aktiviere und starte den uWSGI-Dienst.
$ sudo systemctl enable pgadmin-uwsgi --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status pgadmin-uwsgi
Schritt 9 – SSL installieren
Bevor wir Nginx konfigurieren, müssen wir das SSL-Zertifikat einrichten.
Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot herunterladen. Dazu verwenden wir den Snapd-Paketinstaller.
Installiere den Snap-Installer.
$ sudo apt install snapd
Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt wird, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Beende den Nginx-Server, da er das Certbot-Tool behindert.
$ sudo systemctl stop nginx
Erstelle ein SSL-Zertifikat.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d pgadmin.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/pgadmin.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.
$ sudo mkdir -p /var/lib/letsencrypt
Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.
$ sudo nano /etc/cron.daily/certbot-renew
Füge den folgenden Code ein.
#!/bin/sh certbot renew --cert-name pgadmin.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.
$ sudo chmod +x /etc/cron.daily/certbot-renew
Schritt 10 – Nginx installieren und konfigurieren
Ubuntu wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.20.2
Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/pgadmin.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/pgadmin.conf
Füge den folgenden Code in die Datei ein.
server {
listen 80;
listen [::]:80;
server_name pgadmin.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name pgadmin.example.com;
ssl_certificate /etc/letsencrypt/live/pgadmin.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/pgadmin.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/pgadmin.example.com/chain.pem;
ssl_session_cache builtin:1000 shared:SSL:10m;
ssl_session_timeout 5m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers on;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location /pgadmin4/ {
include /etc/nginx/uwsgi_params;
uwsgi_pass unix:/tmp/pgadmin4.sock;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.
$ sudo systemctl restart nginx
Schritt 11 – Firewall konfigurieren
Bevor wir auf pgAdmin zugreifen, müssen wir sicherstellen, dass die Firewall-Ports geöffnet sind. Wenn du die ufw Firewall verwendest, führe die folgenden Befehle aus, um die HTTP- und HTTPs-Ports zu öffnen.
$ sudo ufw allow 80/tcp $ sudo ufw allow 443/tcp
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443/tcp ALLOW Anywhere 5432/tcp ALLOW 192.168.1.0/24 OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443/tcp (v6) ALLOW Anywhere (v6)
Schritt 11 – pgAdmin aufrufen und konfigurieren
Bevor wir auf pgAdmin zugreifen, müssen wir ein Passwort für den Standardbenutzer postgres festlegen.
Öffne die Shell psql.
$ sudo -u postgres psql
Führe den folgenden Befehl aus, um ein Passwort zu setzen.
postgres-# \password postgres Enter new password for user "postgres": Enter it again:
Beende die Shell.
postgres-# exit
Ändere außerdem den Besitzer des UNIX-Sockets.
$ sudo chown nginx:nginx /var/lib/pgadmin/pgadmin4.sock
Öffne die URL https://pgadmin.example.com in deinem Browser und du wirst den folgenden Anmeldebildschirm sehen.
Gib deine in Schritt 6 erstellten Benutzerdaten ein, um dich anzumelden und auf das folgende Dashboard zuzugreifen.
Im nächsten Schritt fügst du den lokalen PostgreSQL-Server hinzu. Klicke auf die Schaltfläche Neuen Server hinzufügen, um loszulegen.
Vergeben Sie einen Namen für die Verbindung und wechseln Sie zum Reiter Verbindung.
Gib localhost als Hostname ein und lass das Feld Port leer. Füge das zuvor erstellte Passwort hinzu und aktiviere die Option Passwort speichern? Klicke auf die Schaltfläche Speichern, um das Hinzufügen des Servers abzuschließen.
Wenn du fertig bist, siehst du den folgenden Dashboard-Bildschirm für deinen PostgreSQL-Server.
Lass uns eine neue Tabelle erstellen und einige Daten zu unserer Datenbank hinzufügen.
Klicke im Dashboard auf das Pfeilzeichen neben PostgreSQL – Local, um das Baummenü zu erweitern. Erweitere dann die Datenbanken, klicke auf den Namen der Datenbank, die du hinzugefügt hast(in unserem Beispielhowtoforge), und dann auf Schemas. Du solltest das folgende Menü sehen.
Klicke mit der rechten Maustaste auf die Option Tabellen und wähle dann wie abgebildet die Menüoptionen Erstellen >> Tabelle.
Daraufhin öffnet sich das Popup-Fenster Tabelle erstellen, wie unten abgebildet. Gib einen Namen für die Tabelle ein.
Wechsle auf die Registerkarte “ Spalten“. Hier werden wir einige grundlegende Spalten für die Tabelle definieren.
Klicke auf das Pluszeichen, um die erste Spalte hinzuzufügen. Wir haben sie ID genannt und als Datentyp Ganzzahl angegeben. Jede Tabelle sollte einen Primärschlüssel haben. Um die ID zum Primärschlüssel der Tabelle zu machen, klicke auf die Schaltfläche für den Primärschlüssel.
Als Nächstes fügen wir eine weitere Spalte für den Namen mit einem unterschiedlichen Datentyp hinzu. Um die Länge des Namens zu begrenzen, haben wir 30 als Länge festgelegt. Das ist für unser Beispiel ausreichend. Klicke auf die Schaltfläche Speichern, wenn du fertig bist, um die Tabelle zu erstellen.
Jetzt, wo wir unsere Tabelle mit einigen Spalten haben, ist der nächste Schritt, die Tabelle mit einigen Werten zu füllen. Um die Daten hinzuzufügen, klicke mit der rechten Maustaste auf den Namen deiner Tabelle im Browser, bewege den Mauszeiger über Skripte und wähle die Option Skript einfügen.
Es öffnet sich eine neue Registerkarte auf dem Dashboard mit einem teilweise ausgefüllten INSERT Befehl. Ersetze das Fragezeichen durch die entsprechenden Daten, die du einfügen möchtest. Hier sind die Daten, die wir für unsere Tabelle verwendet haben.
INSERT INTO public."table-01"( "ID", "Name") VALUES (1, 'Navjot'), (2, Adam), (3, 'Roxy');
Klicke auf die Schaltfläche mit dem umgekehrten Dreieck, um die SQL-Abfrage auszuführen und die Daten hinzuzufügen.
Als Nächstes möchtest du dir die Daten ansehen, die du gerade hinzugefügt hast. Dazu klickst du mit der rechten Maustaste auf den Tabellennamen, wählst die Option Daten anzeigen/bearbeiten und klickst dann auf die Option Alle Zeilen.
Dadurch öffnet sich eine weitere Registerkarte im Dashboard, in der deine Daten auf der Registerkarte Datenausgabe im unteren Bereich sichtbar sind.
Endlich hast du eine Datenbank erstellt und ihr mit pgAdmin einige Daten hinzugefügt. Mit pgAdmin kannst du noch viel mehr tun.
PostgreSQL verfügt über integrierte Dienstprogramme zum Sichern und Wiederherstellen von Daten. pgAdmin unterstützt diese von Haus aus, aber damit es funktioniert, musst du eventuell den Pfad zu deinen Postgre-Binärdateien hinzufügen. Öffne dazu oben das Menü Datei und wähle die Option Einstellungen.
Es öffnet sich ein neues Popup-Fenster mit einer Vielzahl von Einstellungen. Wähle die Option Pfade >> Binäre Pfade in der linken Seitenleiste. Als Nächstes scrollst du zum Abschnitt PostgreSQL Binary Path des Popup-Fensters herunter.
Gib /usr/bin als Pfad vor dem PostgreSQL 14 Server-Eintrag ein und setze das Häkchen darüber. Klicke auf die Schaltfläche Speichern, wenn du fertig bist. Du solltest nun in der Lage sein, die Befehle zum Sichern und Wiederherstellen über die pgAdmin-Oberfläche zu verwenden.
Fazit
Du hast gelernt, PostgreSQL und pgAdmin auf einem Ubuntu 22.04 Server zu installieren. Außerdem hast du pgAdmin so konfiguriert, dass es sich mit dem PostgreSQL-Dienst verbindet und grundlegende Operationen durchführt. Wenn du Fragen hast, schreibe sie unten in die Kommentare.