HowtoForge

So installierst du einen CockroachDB Cluster unter Ubuntu 22.04

von ·

CockroachDB ist eine kostenlose und Cloud-native verteilte SQL-Datenbank, mit der du moderne, skalierbare Cloud-Dienste aufbauen und verwalten kannst. Sie hilft dir, Software- und Hardwareausfälle zu überstehen. Sie speichert Kopien der Daten an mehreren Orten, um einen schnellen Zugriff zu ermöglichen. Sie basiert auf einem transaktionalen und stark konsistenten Key-Value-Store und ist in der Lage, Festplatten-, Rechner- und Rechenzentrumsausfälle mit nahezu null Latenz und ohne manuelles Eingreifen zu überstehen.

In diesem Tutorial wird erklärt, wie du einen CockroachDB-Cluster mit drei Knoten auf einem Ubuntu 22.04-Server einrichtest.

Voraussetzungen

  • Drei Server, auf denen Ubuntu 22.04 läuft.
  • Auf jedem Server ist ein Root-Passwort eingerichtet.

In diesem Tutorial verwenden wir die folgenden Einstellungen:

HostnameIP-Adresse

Knoten1 192.168.10.10

Knoten2 192.168.10.11

Knoten3 192.168.10.12

Aktualisiere dein System

Bevor du startest, solltest du alle Knotenpunkte auf die neueste Version aktualisieren und upgraden. Du kannst alle Knoten nacheinander aktualisieren, indem du den folgenden Befehl ausführst:

apt update -y
apt upgrade -y

Wenn alle Knoten auf dem neuesten Stand sind, starte sie neu, damit die Änderungen übernommen werden.

Zeitsynchronisation einrichten

Bevor du loslegst, musst du eine Zeitsynchronisation zwischen allen Knotenpunkten einrichten. Das kannst du mit dem Programm chrony tun.

Installiere zunächst chrony mit dem folgenden Befehl:

apt install chrony -y

Nach der Installation bearbeitest du die Konfigurationsdatei von chrony mit dem folgenden Befehl:

nano /etc/chrony/chrony.conf

Finde den Standardpool und ersetze ihn durch die folgenden Zeilen:

pool 0.id.pool.ntp.org iburst maxsources 4
pool 1.id.pool.ntp.org iburst maxsources 1
pool 2.id.pool.ntp.org iburst maxsources 1
pool 3.id.pool.ntp.org iburst maxsources 2

Speichere und schließe die Datei. Starte dann den chrony-Dienst neu und aktiviere ihn mit folgendem Befehl, damit er beim Neustart des Systems startet:

systemctl restart chrony
systemctl enable chrony

Wenn du damit fertig bist, kannst du mit dem nächsten Schritt fortfahren.

CockroachDB auf allen Knotenpunkten installieren

In diesem Abschnitt werden wir CockroachDB auf allen Knoten installieren. Führe die folgenden Befehle auf allen Knotenpunkten aus, um CockroachDB zu installieren.

Lade zunächst die neueste Version von CockroachDB mit folgendem Befehl von der offiziellen Website herunter:

wget https://binaries.cockroachdb.com/cockroach-latest.linux-amd64.tgz

Sobald der Download abgeschlossen ist, entpackst du die heruntergeladene Datei mit dem folgenden Befehl:

tar -xvzf cockroach-latest.linux-amd64.tgz

Als Nächstes kopierst du die CockroachDB-Binärdatei mit dem folgenden Befehl in das Verzeichnis /usr/local/bin:

cp cockroach-*/cockroach /usr/local/bin/

Überprüfe die CockroachDB-Version mit folgendem Befehl:

cockroach version

Du solltest die folgende Ausgabe erhalten:

Build Tag:        v22.2.2
Build Time:       2023/01/04 17:23:00
Distribution:     CCL
Platform:         linux amd64 (x86_64-pc-linux-gnu)
Go Version:       go1.19.1
C Compiler:       gcc 6.5.0
Build Commit ID:  07a53a36601e9ca5fcffcff55f69b43c6dfbf1c1
Build Type:       release

Zu diesem Zeitpunkt ist CockroachDB auf allen Knotenpunkten installiert. Du kannst nun mit dem nächsten Schritt fortfahren.

Erstellen von Zertifikaten

CockroachDB benötigt für eine sichere Verbindung auch Server- und Client-Zertifikate. Erstelle zunächst auf allen Knoten ein Verzeichnis zum Speichern der Zertifikatsdateien. Führe den folgenden Befehl auf allen Knoten aus, um ein certs-Verzeichnis zu erstellen:

mkdir ~/certs

Als Nächstes musst du ein CA-Zertifikat, ein Root-Zertifikat und ein Client-Zertifikat erstellen.

CA-Zertifikat erstellen

Erstelle auf Knoten 1 ein CA-Zertifikat mit dem folgenden Befehl:

cockroach cert create-ca --certs-dir=certs --ca-key=certs/ca.key

Dieser Befehl erzeugt ca.key und ca.crt im Verzeichnis ~/certs.

Kopiere dann die erzeugte CA mit dem folgenden Befehl auf beide Knoten:

scp ~/certs/ca.crt ~/certs/ca.key root@192.168.10.11:~/certs/
scp ~/certs/ca.crt ~/certs/ca.key root@192.168.10.12:~/certs/

Client-Zertifikat erstellen

Als Nächstes musst du ein Client-Zertifikat erstellen, um die Kommunikation zwischen SQL und dem Cluster zu sichern.

Führe den folgenden Befehl auf allen Knoten aus, um das Client-Zertifikat zu erstellen:

cockroach cert create-client root --certs-dir=certs --ca-key=certs/ca.key

Sobald du damit fertig bist, kannst du mit der Erstellung eines Serverzertifikats fortfahren.

Server-Zertifikate erstellen

Als Nächstes musst du das Serverzertifikat erstellen, um die Kommunikation zwischen den Servern des CockroachDB-Clusters zu sichern.

Auf Node1 führst du den folgenden Befehl aus, um das Serverzertifikat zu erstellen:

cockroach cert create-node localhost $(hostname) 192.168.10.10 --certs-dir=certs --ca-key=certs/ca.key

Auf Node2 führst du den folgenden Befehl aus, um das Serverzertifikat zu erzeugen:

cockroach cert create-node localhost $(hostname) 192.168.10.11 --certs-dir=certs --ca-key=certs/ca.key

Auf Node3 führst du den folgenden Befehl aus, um das Serverzertifikat zu erzeugen:

cockroach cert create-node localhost $(hostname) 192.168.10.12 --certs-dir=certs --ca-key=certs/ca.key

Dadurch werden die Dateien node.key und node.crt im Verzeichnis ~/certs erzeugt.

Du kannst alle Zertifikate mit dem folgenden Befehl auflisten:

cockroach --certs-dir=certs cert list

Du solltest die folgende Ausgabe erhalten:

Certificate directory: certs
  Usage  | Certificate File |    Key File     |  Expires   |                   Notes                    | Error
---------+------------------+-----------------+------------+--------------------------------------------+--------
  CA     | ca.crt           |                 | 2033/01/17 | num certs: 1                               |
  Node   | node.crt         | node.key        | 2028/01/14 | addresses: localhost,vultr,192.168.10.10 |
  Client | client.root.crt  | client.root.key | 2028/01/14 | user: root                                 |
(3 rows)

Wenn du damit fertig bist, kannst du mit dem nächsten Schritt fortfahren.

CockroachDB Cluster starten

Jetzt sind alle Zertifikate bereit, um den CockroachDB-Cluster zu starten.

Führe auf Node1 den folgenden Befehl aus, um den Secure CockroachDB Cluster anzukündigen:

cockroach start --background --certs-dir=certs --advertise-host=192.168.10.10 --join=192.168.10.10,192.168.10.11,192.168.10.12 --background

Du solltest die folgende Ausgabe erhalten.

* WARNING: Running a server without --sql-addr, with a combined RPC/SQL listener, is deprecated.
* This feature will be removed in the next version of CockroachDB.
*
*
* INFO: initial startup completed.
* Node will now attempt to join a running cluster, or wait for `cockroach init`.
* Client connections will be accepted after this completes successfully.
* Check the log file(s) for progress.

Als nächstes initialisierst du den Cluster mit dem folgenden Befehl.

cockroach init --certs-dir=certs --host=192.168.10.10

Standardmäßig lauscht der CockroachDB-Cluster auf Port 26257. Du kannst dies mit dem folgenden Befehl überprüfen.

ss -antpl | grep 26257

Du erhältst die folgende Ausgabe.

LISTEN 0      4096               *:26257            *:*    users:(("cockroach",pid=86868,fd=25))

Du kannst auch den Status des Clusters mit dem folgenden Befehl überprüfen:

cockroach node status --certs-dir=certs --host=192.168.10.10

Du solltest die folgende Ausgabe erhalten:

  id |        address        |      sql_address      |  build  |              started_at              |              updated_at              | locality | is_available | is_live
-----+-----------------------+-----------------------+---------+--------------------------------------+--------------------------------------+----------+--------------+----------
   1 | 192.168.10.10:26257 | 192.168.10.10:26257 | v22.2.2 | 2023-01-10 07:19:44.009519 +0000 UTC | 2023-01-10 07:20:24.521341 +0000 UTC |          | true         | true
(1 row)

Wenn du fertig bist, kannst du mit dem nächsten Schritt fortfahren.

Restliche Knoten zum Cluster hinzufügen

Als Nächstes musst du beide Knoten zum CockroachDB-Cluster hinzufügen.

Führe auf Knoten 2 den folgenden Befehl aus, um ihn zum CockroachDB-Cluster hinzuzufügen.

cockroach start --background --certs-dir=certs --advertise-host=192.168.10.11 --listen-addr=192.168.10.11 --join=192.168.10.10:26257

Auf dem Knoten 3 führst du den folgenden Befehl aus, um ihn dem CockroachDB-Cluster hinzuzufügen.

cockroach start --background --certs-dir=certs --advertise-host=192.168.10.12 --listen-addr=192.168.10.12 --join=192.168.10.10:26257

Gehe dann zurück zu Knoten 1 und überprüfe den Status des Clusters mit dem folgenden Befehl:

cockroach node status --certs-dir=certs --host=192.168.10.10

Du solltest sehen, dass alle Knoten dem Cluster hinzugefügt wurden.

  id |        address        |      sql_address      |  build  |              started_at              |              updated_at              | locality | is_available | is_live
-----+-----------------------+-----------------------+---------+--------------------------------------+--------------------------------------+----------+--------------+----------
   1 | 192.168.10.10:26257 | 192.168.10.10:26257 | v22.2.2 | 2023-01-10 07:19:44.009519 +0000 UTC | 2023-01-10 07:21:27.529911 +0000 UTC |          | true         | true
   2 | 192.168.10.11:26257  | 192.168.10.11:26257  | v22.2.2 | 2023-01-10 07:21:04.206015 +0000 UTC | 2023-01-10 07:21:26.718227 +0000 UTC |          | true         | true
   3 | 192.168.10.12:26257 | 192.168.10.12:26257 | v22.2.2 | 2023-01-10 07:21:17.704146 +0000 UTC | 2023-01-10 07:21:26.718768 +0000 UTC |          | true         | true

Zu diesem Zeitpunkt ist der CockroachDB-Cluster gestartet und lauscht auf Port 8080. Du kannst nun mit dem nächsten Schritt fortfahren.

Zugang zum CockroachDB Dashboard

CockroachDB bietet eine einfache und leicht zu bedienende Weboberfläche zur Überwachung des Clusters. Bevor du auf die CockroachDB-Weboberfläche zugreifen kannst, musst du einen Admin-Benutzer anlegen und ein Passwort für ihn festlegen.

Melde dich auf Node1 mit folgendem Befehl in der cockroachdb SQL-Shell an:

cockroach sql --certs-dir=certs --host=192.168.10.10

Als Nächstes erstellst du einen Benutzer namens user1 und legst das Passwort mit dem folgenden Befehl fest:

root@192.168.10.10:26257/defaultdb> CREATE USER user1 WITH PASSWORD 'securepassword';

Verlasse die SQL-Shell mit folgendem Befehl.

root@192.168.10.10:26257/defaultdb> exit;

Öffne nun deinen Webbrowser und rufe die CockroachDB-Weboberfläche über die URL https://node1-ip-address:8080 auf. Du solltest die folgende Seite sehen:

CockroachDB

Gib deinen Admin-Benutzernamen und dein Passwort ein und klicke auf die Schaltfläche LOG IN. Auf der folgenden Seite solltest du das CockroachDB-Dashboard sehen:

CockroachDB Dashboard

Überprüfe die Datenbankreplikation in Custer

Als Nächstes musst du überprüfen, ob die Datenbank zwischen allen Knoten repliziert ist oder nicht.

Melde dich auf Knoten1 mit folgendem Befehl in der SQL-Shell an:

cockroach sql --certs-dir=certs --host=192.168.10.10

Als Nächstes erstellst du eine Datenbank namens wpdb1 und wpdb2 mit folgendem Befehl:

create database wpdb1;
create database wpdb2;

Überprüfe dann die Datenbanken mit dem folgenden Befehl:

show databases;

Du solltest alle Datenbanken in der folgenden Ausgabe sehen:

  database_name | owner | primary_region | secondary_region | regions | survival_goal
----------------+-------+----------------+------------------+---------+----------------
  defaultdb     | root  | NULL           | NULL             | {}      | NULL
  postgres      | root  | NULL           | NULL             | {}      | NULL
  system        | node  | NULL           | NULL             | {}      | NULL
  wpdb1         | root  | NULL           | NULL             | {}      | NULL
  wpdb2         | root  | NULL           | NULL             | {}      | NULL
(5 rows)


Time: 3ms total (execution 3ms / network 1ms)

Als Nächstes gehst du zu Node2 und überprüfst, ob die Datenbank repliziert ist oder nicht.

Melde dich auf Node2 mit folgendem Befehl in der SQL-Shell an:

cockroach sql --certs-dir=certs --host=192.168.10.11

Führe den folgenden Befehl aus, um die Datenbanken anzuzeigen:

show databases;

In der folgenden Ausgabe solltest du die wpdb1 und wpdb2 sehen:

  database_name | owner | primary_region | secondary_region | regions | survival_goal
----------------+-------+----------------+------------------+---------+----------------
  defaultdb     | root  | NULL           | NULL             | {}      | NULL
  postgres      | root  | NULL           | NULL             | {}      | NULL
  system        | node  | NULL           | NULL             | {}      | NULL
  wpdb1         | root  | NULL           | NULL             | {}      | NULL
  wpdb2         | root  | NULL           | NULL             | {}      | NULL
(5 rows)


Time: 7ms total (execution 6ms / network 1ms)

Die obige Ausgabe zeigt, dass die Datenbankreplikation auf dem CockroachDB Cluster funktioniert.

Fazit

In dieser Anleitung wurde erklärt, wie du einen sicheren CockroachDB Cluster auf einem Ubuntu 22.04 Server installierst und einrichtest. Du kannst deinen Cluster jetzt ganz einfach skalieren, indem du weitere Knoten zum Cluster hinzufügst. Wenn du noch Fragen hast, kannst du dich gerne an mich wenden. Weitere Informationen findest du in der offiziellen CockroachDB-Dokumentation.

Das könnte dich auch interessieren …