Migration von Daten von Zalando zu CloudNativePG auf Linux x86_64 und Linux on IBM Z und LinuxONE Clustern

Sie können Daten von Zalando zu CloudNativePG übertragen, indem Sie den pg_basebackup Bootstrap-Modus innerhalb eines Clusters verwenden, der im Replikationsmodus arbeitet. Um die Daten zu übertragen, müssen Sie den CloudNativePG Replikationscluster (Ziel) erstellen, der den Zalando-Datenspeicher (Quelle) repliziert.

Voraussetzungen

Führen Sie die folgenden Schritte aus, um Bootstrapping über einen Live-Cluster durchzuführen:

Stellen Sie sicher, dass das Ziel und die Quelle dieselbe PostgreSQL -Hauptversion haben.
Richten Sie den streaming_replica -Benutzer mit Replikations-und Anmelderollen in der Zalando- PostgreSQL -Datenbank ein.

Anpassung des Zalando Postgres -Datenspeichers für die Datenmigration

Führen Sie die folgenden Schritte aus, um den Zalando-Datenspeicher Postgres für die Datenmigration zu ändern:

Stellen Sie eine Verbindung zum Zalando-Pod her:
1. Zeigen Sie die Details des primären Pods an:
```
kubectl get pods -o jsonpath={.items..metadata.name} -l application=spilo,spilo-role=master -n instana-postgres
```
2. Führen Sie Befehle direkt im Pod aus:
```
kubectl exec -it <primary_pod_name> -n instana-postgres
```
3. Verbinden Sie sich mit der Postgres:
```
psql -U postgres
```
4. Listen Sie die Rollen auf und erstellen Sie einen Benutzer " streaming_replica mit Replikations- und Login-Rollen in der Zalando-Datenbank:
```
\du
CREATE ROLE streaming_replica WITH REPLICATION;
ALTER ROLE streaming_replica WITH LOGIN PASSWORD '<password_retrived_from_zalando>';
```
5. Beenden Sie das interaktive PostgreSQL:
```
\q
```
Erstellen Sie zwei leere Dateien namens custom.conf und override.conf im Verzeichnis pgdata für alle Pods, die sich neben der Datei postgresql.conf befinden.
1. Listen Sie die Pods auf:
```
kubectl get pods -n instana-postgres
```
2. Führen Sie Befehle direkt auf dem Pod aus. Führen Sie den folgenden Befehl für alle Pods aus:
```
kubectl exec -it <pod_name> -n instana-postgres
```
```
cd /var/lib/postgresql/data/pgdata
touch -f custom.conf
touch -f override.conf
```
Verlassen Sie das Pod-Terminal:
```
exit
```

Erstellen eines Postgres -Datenspeichers mithilfe des CloudNativePG Postgres -Operators für die Datenmigration

Installation des Postgres -Betreibers online

Um den CloudNativePG Postgres Operator online einzusetzen, führen Sie die folgenden Schritte aus:
1. Erstellen Sie den Namensbereich instana-postgres-01 :
```
kubectl create namespace instana-postgres-01
```
2. Bestimmen Sie die Dateisystemgruppen-ID unter Red Hat OpenShift.
  
  Red Hat OpenShift erfordert, dass Dateisystemgruppen innerhalb eines Wertebereichs liegen, der für den Namensbereich spezifisch ist. Führen Sie auf dem Cluster, auf dem der CloudNativePG Kubernetes Operator bereitgestellt wird, den folgenden Befehl aus:
```
kubectl get namespace instana-postgres-01 -o yaml
```
  Für den Befehl wird eine Ausgabe ähnlich der folgenden angezeigt:
```
apiVersion: v1
kind: Namespace
metadata:
  annotations:
    .......
    openshift.io/sa.scc.uid-range: 1000750000/10000
  creationTimestamp: "2024-01-14T07:04:59Z"
  labels:
    kubernetes.io/metadata.name: instana-postgres-01
    .......
  name: instana-postgres-01
```
  Die Annotation openshift.io/sa.scc.supplemental-groups enthält den Bereich der zulässigen IDs. Der Bereich 1000750000/10000 gibt 10.000 Werte an, die mit der ID 1000750000beginnen, sodass er den Bereich der IDs von 1000750000 bis 1000760000angibt. In diesem Beispiel kann der Wert 1000750000 als Dateisystemgruppen-ID verwendet werden.
3. Installieren Sie den CloudNativePG Postgres Operator, indem Sie die folgenden Helm Befehle ausführen:
```
helm repo add instana https://artifact-public.instana.io/artifactory/rel-helm-customer-virtual --username=_ --password=<AGENT_KEY>
```
```
helm repo update
```
```
helm install cnpg instana/cloudnative-pg --set image.repository=artifact-public.instana.io/self-hosted-images/3rd-party/operator/cloudnative-pg --set image.tag=v1.26.0_v0.17.0 --version=0.24.0 --set imagePullSecrets[0].name=instana-registry --set containerSecurityContext.runAsUser=<UID from namespace> --set containerSecurityContext.runAsGroup=<UID from namespace> -n instana-postgres-01
```
Erstellen Sie geheime Schlüssel für Image-Pull-Operationen für den Namensbereich instana-postgres-01 :
```
kubectl create secret docker-registry instana-registry -n instana-postgres-01 \
--docker-username=_ \
--docker-password=<AGENT_KEY> \
--docker-server=artifact-public.instana.io
```
Hinweis: Aktualisieren Sie vor der Erstellung des geheimen Schlüssels den Wert < AGENT_KEY> mit Ihrem eigenen Agentenschlüssel.

Erstellen Sie eine Datei, z. B. postgres-secret.yaml, für den Zugriff auf externe Cluster:

kind: Secret
apiVersion: v1
metadata:
  name: instanaadmin
type: Opaque
stringData:
  username: instanaadmin
  password: <user_generated_password_from_zalando>

Wenden Sie die Datei " postgres-secret.yaml an:

kubectl apply -f postgres-secret.yaml -n instana-postgres-01

Erstellen Sie eine CloudNativePG Cluster Ressource im replica Modus:

Erstellen Sie wie folgt eine Datei wie beispielsweise cnpg-postgres.yaml:

apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: postgres
spec:
  instances: 3
  imageName: artifact-public.instana.io/self-hosted-images/3rd-party/cnpg-containers:15_v0.19.0
  imagePullPolicy: IfNotPresent
  imagePullSecrets:
    - name: instana-registry
  enableSuperuserAccess: true
  replicationSlots:
    highAvailability:
      enabled: true
  managed:
    roles:
    - name: instanaadmin
      login: true
      superuser: true
      createdb: true
      createrole: true
      replication: true
      passwordSecret:
        name: instanaadmin
  postgresql:
    pg_hba:
      - local     all          all                            trust
      - host      replication  postgres          all          trust
      - host      replication  streaming_replica 0.0.0.0/0    trust
      - host      all          all               0.0.0.0/0    trust
      - local     replication  standby                        trust
      - hostssl   replication  standby      all               md5
      - hostnossl all          all          all               reject
      - hostssl   all          all          all               md5
  bootstrap:
    pg_basebackup:
      source: zalando-postgres
  replica:
    enabled: true
    source: zalando-postgres

  externalClusters:
  - name: zalando-postgres
    connectionParameters:
      host: postgres.instana-postgres.svc
      user: postgres
    password:
      name: instanaadmin
      key: password

  superuserSecret:
    name: instanaadmin

  storage:
    size: 20Gi
    storageClass: nfs-client

Wenden Sie die Datei cnpg-postgres.yaml an, indem Sie den folgenden Befehl ausführen:
```
kubectl apply -f cnpg-postgres.yaml -n instana-postgres-01
```

Wechseln Sie per SSH in den Debug-Container des ersten CloudNativePG-Pods, um postgresql.conf zu ändern.

Nach der Initialisierung des Clusters im Replikatmodus lautet der ursprüngliche Pod-Status (postgres-1-pgbasebackup) Completed. Spätere Versuche, den ersten CloudNativePG Pod (postgres-1) zu starten, schlagen fehl. Dies entspricht dem erwarteten Verhalten.

Führen Sie die folgenden Schritte aus, um eine erfolgreiche Initialisierung von Cluster und das nachfolgende Starten des Pods sicherzustellen:
1. Führen Sie die folgenden Befehle aus, um den ursprünglichen Pod zu ermitteln, SSH darin zu verwenden und in das Verzeichnis zu wechseln, das den Datenträger pgdata enthält:
```
kubectl debug pod/postgres-1 --as-root -n instana-postgres-01
```
```
cd /var/lib/postgresql/data/pgdata/
```
2. Ändern Sie die Pfade pg_hba und pg_ident in der Datei postgresql.conf in jedem Pod:
  - Ändern Sie den Pfad pg_hba von /var/lib/postgresql/15/main/pg_hba.conf in den folgenden Pfad:
```
/var/lib/postgresql/data/pgdata/pg_hba.conf
```
  - Ändern Sie den Pfad pg_ident von /var/lib/postgresql/15/main/pg_ident.conf in den folgenden Pfad:
```
/var/lib/postgresql/data/pgdata/pg_ident.conf
```
3. Fügen Sie am Ende der Datei include 'custom.conf' und include 'override.conf' hinzu:
```
echo "include 'custom.conf'" >> postgresql.conf
echo "include 'override.conf'" >> postgresql.conf
```
Starten Sie den Pod erneut. Nach dem Start des Pods replizieren sich alle Pods vom ersten Pod aus.
Verwenden Sie den neuen cnpg-Cluster.
1. Inaktivieren Sie den Replikatcluster:
  1. Ändern Sie die Datei cnpg-postgres.yaml :
```
........
replica:
enabled: false
source: zalando-postgres
..........
```
  2. Wenden Sie die Datei cnpg-postgres.yaml erneut an:
```
kubectl apply -f cnpg-postgres.yaml -n instana-postgres-01
```
2. Stellen Sie eine Verbindung zur Datenbank her:
```
psql -U postgres
```
3. Aktualisieren Sie die Sortierungsversion:
```
ALTER DATABASE template1 REFRESH COLLATION VERSION;
```
Aktualisieren Sie die Konfiguration der Kernspezifikation:
1. Aktualisieren Sie in Ihrer Instana Core-Datei die Konfiguration " postgresConfig wie im folgenden Beispiel gezeigt:
```
.....................
postgresConfigs:
  - authEnabled: true
     hosts:
       - postgres-rw.instana-postgres-01
.....................
```
2. Wenden Sie die Datei core.yaml erneut an:
```
kubectl apply -f core.yaml -n instana-core
```