Migration von Daten von Zalando zu CloudNativePG auf Linux on Power ( ppc64le ) -Clustern

Online bearbeiten

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

Voraussetzungen

Online bearbeiten

Um von einem Live-Cluster zu booten, führen Sie die folgenden Schritte aus:

Stellen Sie sicher, dass Ziel und Quelle dieselbe Haupt PostgreSQL -Version haben.
Richten Sie den streaming_replica Benutzer mit Replikations- und Anmelderollen in der Datenbank „ ZalandoPostgreSQL “ ein.

Ändern des Datenspeichers „ ZalandoPostgres “ für die Datenmigration

Online bearbeiten

Um den Datenspeicher „ Zalando “ ( Postgres ) für die Datenmigration zu ändern, führen Sie die folgenden Schritte aus:

Verbinden Sie sich mit dem Pod „ Zalando “:
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. Befehle direkt im Pod ausführen:
```
kubectl exec -it <primary_pod_name> -n instana-postgres
```
3. Verbindung zur Datenbank „ Postgres “ herstellen:
```
psql -U postgres
```
4. Listen Sie die Rollen auf und erstellen Sie einen streaming_replica Benutzer mit Replikations- und Anmelderollen in der Datenbank „ Zalando “:
```
\du
CREATE ROLE streaming_replica WITH REPLICATION;
ALTER ROLE streaming_replica WITH LOGIN PASSWORD '<password_retrived_from_zalando>';
```
5. Beenden Sie das interaktive Terminal „ PostgreSQL “:
```
\q
```
Erstellen Sie zwei leere Dateien mit den Namen custom.conf und override.conf im pgdata Verzeichnis auf allen Pods, die sich neben der postgresql.conf Datei befinden.
1. Listen Sie die Pods auf:
```
kubectl get pods -n instana-postgres
```
2. Befehle direkt auf dem Pod ausführen. Führen Sie den folgenden Befehl auf allen Pods aus:
```
kubectl exec -it <pod_name> -n instana-postgres
```
```
cd /var/lib/postgresql/data/pgdata
touch -f custom.conf
touch -f override.conf
```
Ausgang aus dem Pod-Terminal:
```
exit
```

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

Online bearbeiten

Postgres -Operator online installieren

Online bearbeiten

Um den „ CloudNativePGPostgres “-Operator online bereitzustellen, führen Sie die folgenden Schritte aus:
1. Erstellen Sie den instana-postgres-01 Namespace:
```
kubectl create namespace instana-postgres-01
```
2. Bestimmen Sie die Dateisystem-Gruppen-ID auf Red Hat OpenShift.
  
  Red Hat OpenShift erfordert, dass Dateisystemgruppen innerhalb eines für den Namespace spezifischen Wertebereichs liegen. Führen Sie auf dem Cluster, auf dem der Operator „ CloudNativePGKubernetes ” bereitgestellt ist, den folgenden Befehl aus:
```
kubectl get namespace instana-postgres-01 -o yaml
```
  Für den Befehl wird eine Ausgabe ähnlich dem folgenden Beispiel 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 openshift.io/sa.scc.supplemental-groups Anmerkung enthält den Bereich der zulässigen IDs. Der Bereich 1000750000/10000 bezeichnet 10.000 Werte, die mit 1000750000 der ID beginnen, und gibt somit den Bereich der IDs von 1000750000 bis 1000760000an. In diesem Beispiel könnte der 1000750000 Wert als Dateisystem-Gruppen-ID verwendet werden.
3. Installieren Sie den Operator „ CloudNativePGPostgres “, indem Sie die folgenden Befehle in der Befehlszeile „ Helm “ 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.29.1_v0.34.0 --version=0.28.2 --set imagePullSecrets[0].name=instana-registry --set containerSecurityContext.runAsUser=<UID from namespace> --set containerSecurityContext.runAsGroup=<UID from namespace> -n instana-postgres-01
```
Erstellen Sie Image-Pull-Geheimnisse für den instana-postgres-01 Namespace:
```
kubectl create secret docker-registry instana-registry -n instana-postgres-01 \
--docker-username=_ \
--docker-password=<AGENT_KEY> \
--docker-server=artifact-public.instana.io
```
Hinweis: Bevor Sie das Geheimnis erstellen, aktualisieren Sie den Wert <AGENT_KEY> mit Ihrem eigenen Agentenschlüssel.

Erstellen Sie eine Datei, z. B. postgres-secret.yaml, für den externen Clusterzugriff:

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

Wenden Sie die postgres-secret.yaml Datei an:

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

Erstellen Sie eine Ressource Cluster „ CloudNativePG “ im replica Modus:

Erstellen Sie eine Datei, z. B. cnpg-postgres.yaml, wie folgt:

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.39.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 cnpg-postgres.yaml Datei an, indem Sie den folgenden Befehl ausführen:
```
kubectl apply -f cnpg-postgres.yaml -n instana-postgres-01
```

SSH in den Debug-Container des ersten Pods „ CloudNativePG “, um. zu ändern postgresql.conf.

Nach der Initialisierung des Clusters im Replikationsmodus lautet der anfängliche Completed Pod-Status (postgres-1-pgbasebackup). Nachfolgende Versuche, den ersten Pod „ CloudNativePGpostgres-1“ zu starten, schlagen fehl. Dies entspricht dem erwarteten Verhalten.

Um die erfolgreiche Initialisierung des Cluster und den anschließenden Start des Pods sicherzustellen, führen Sie die folgenden Schritte aus:
1. Führen Sie die folgenden Befehle aus, um den ursprünglichen Pod zu ermitteln, sich per SSH darin anzumelden und zu dem Verzeichnis zu wechseln, das das pgdata Volume 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_hbapg_ident und in der postgresql.conf Datei in jedem Pod:
  - Ändern Sie den pg_hba Pfad von /var/lib/postgresql/15/main/pg_hba.conf zu folgendem Pfad:
```
/var/lib/postgresql/data/pgdata/pg_hba.conf
```
  - Ändern Sie den pg_ident Pfad von /var/lib/postgresql/15/main/pg_ident.conf zu folgendem Pfad:
```
/var/lib/postgresql/data/pgdata/pg_ident.conf
```
3. Fügen Sie am Ende include 'custom.conf'include 'override.conf' der Datei und hinzu:
```
echo "include 'custom.conf'" >> postgresql.conf
echo "include 'override.conf'" >> postgresql.conf
```
Starten Sie den Pod erneut. Nachdem der Pod gestartet ist, replizieren sich alle Pods vom ersten Pod aus.
Verwenden Sie den neuen cnpg-Cluster.
1. Deaktivieren Sie den Replikationscluster:
  1. Ändern Sie die cnpg-postgres.yaml Datei:
```
........
replica:
enabled: false
source: zalando-postgres
..........
```
  2. Die cnpg-postgres.yaml Datei erneut anwenden:
```
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 Sortierversion:
```
ALTER DATABASE template1 REFRESH COLLATION VERSION;
```
Aktualisieren Sie die Kernspezifikationskonfiguration:
1. Aktualisieren Sie in Ihrer Datei „ Instana Core“ die postgresConfig Konfiguration wie im folgenden Beispiel gezeigt:
```
.....................
postgresConfigs:
  - authEnabled: true
     hosts:
       - postgres-rw.instana-postgres-01
.....................
```
2. Die core.yaml Datei erneut anwenden:
```
kubectl apply -f core.yaml -n instana-core
```