Migrazione dei dati da Zalando a CloudNativePG su cluster Linux on Power ( ppc64le )

Modifica online

È possibile trasferire i dati da Zalando a CloudNativePG utilizzando la pg_basebackup modalità bootstrap all'interno di un cluster che opera in modalità replica. Per trasferire i dati, è necessario creare il cluster replica (destinazione) CloudNativePG che replica l'archivio dati (origine) Zalando.

Prerequisiti

Modifica online

Per eseguire il bootstrap da un cluster live, completare i seguenti passaggi:

Assicurarsi che la destinazione e l'origine abbiano la stessa versione principale di PostgreSQL.
Configurare streaming_replica l'utente con i ruoli di replica e accesso nel database Zalando PostgreSQL.

Modifica dell'archivio dati Zalando Postgres per la migrazione dei dati

Modifica online

Per modificare l'archivio dati Zalando Postgres per la migrazione dei dati, completare i seguenti passaggi:

Connettiti al pod Zalando :

Visualizza i dettagli del pod primario:

kubectl get pods -o jsonpath={.items..metadata.name} -l application=spilo,spilo-role=master -n instana-postgres

Esegui i comandi direttamente nel pod:

kubectl exec -it <primary_pod_name> -n instana-postgres

Connettiti al database dell' Postgres :
```
psql -U postgres
```

Elenca i ruoli e crea un streaming_replica utente con ruoli di replica e accesso nel database Zalando :

\du
CREATE ROLE streaming_replica WITH REPLICATION;
ALTER ROLE streaming_replica WITH LOGIN PASSWORD '<password_retrived_from_zalando>';

Esci dal terminale interattivo dell' PostgreSQL :
```
\q
```

Crea due file vuoti denominati custom.conf e override.conf all'interno della pgdata directory su tutti i pod, che si trovano accanto al postgresql.conf file.
1. Elenca i pod:
```
kubectl get pods -n instana-postgres
```
2. Esegui i comandi direttamente sul pod. Esegui il seguente comando su tutti i pod:
```
kubectl exec -it <pod_name> -n instana-postgres
```
```
cd /var/lib/postgresql/data/pgdata
touch -f custom.conf
touch -f override.conf
```
Uscita dal terminal pod:
```
exit
```

Creazione di un archivio dati di tipo " Postgres " utilizzando l'operatore " CloudNativePGPostgres " per la migrazione dei dati

Modifica online

Installazione online dell'operatore Postgres

Modifica online

Per distribuire online l'operatore Postgres dell' CloudNativePG, completare i seguenti passaggi:
1. Crea lo instana-postgres-01 spazio dei nomi:
```
kubectl create namespace instana-postgres-01
```
2. Determinare l'ID del gruppo del file system su Red Hat OpenShift.
  
  Red Hat OpenShift richiede che i gruppi del file system rientrino in un intervallo di valori specifico per lo spazio dei nomi. Sul cluster in cui è distribuito l'operatore CloudNativePG Kubernetes, eseguire il comando seguente:
```
kubectl get namespace instana-postgres-01 -o yaml
```
  Per il comando viene visualizzato un output simile al seguente esempio:
```
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
```
  L'annotazione openshift.io/sa.scc.supplemental-groups contiene l'intervallo degli ID consentiti. L'intervallo 1000750000/10000 indica 10.000 valori che iniziano con l'ID 1000750000, quindi specifica l'intervallo di ID da 1000750000 a 1000760000. In questo esempio, il valore 1000750000 potrebbe essere utilizzato come ID di gruppo del file system.
3. Installare l'operatore Postgres dell' CloudNativePG eseguendo i seguenti comandi Helm :
```
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
```

Crea segreti di pull delle immagini per il 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

Nota: prima di creare il segreto, aggiorna il valore <AGENT_KEY> con la tua chiave agente.

Creare un file, ad esempio postgres-secret.yaml, per l'accesso al cluster esterno:

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

Applica il postgres-secret.yaml file:

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

Crea una risorsa Cluster CloudNativePG in replica modalità:

Crea un file, ad esempio cnpg-postgres.yaml, come segue:

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

Applica il cnpg-postgres.yaml file eseguendo il seguente comando:
```
kubectl apply -f cnpg-postgres.yaml -n instana-postgres-01
```

Eseguire SSH nel contenitore di debug del primo pod dell' CloudNativePG e per modificare postgresql.conf.

Dopo l'inizializzazione del cluster in modalità replica, lo stato iniziale del Pod (postgres-1-pgbasebackup) sarà Completed. I tentativi successivi di avviare il primo pod CloudNativePG (postgres-1) falliranno. Questo è un comportamento previsto.

Per garantire il corretto avvio del Cluster e il successivo avvio del Pod, completare i seguenti passaggi:
1. Esegui i seguenti comandi per individuare il Pod iniziale, accedervi tramite SSH e vai alla directory che contiene il pgdata volume:
```
kubectl debug pod/postgres-1 --as-root -n instana-postgres-01
```
```
cd /var/lib/postgresql/data/pgdata/
```
2. Modifica i percorsi pg_hba pg_ident e all'interno del postgresql.conf file in ogni pod:
  - Modifica il pg_hba percorso da /var/lib/postgresql/15/main/pg_hba.conf al seguente percorso:
```
/var/lib/postgresql/data/pgdata/pg_hba.conf
```
  - Modifica il pg_ident percorso da /var/lib/postgresql/15/main/pg_ident.conf al seguente percorso:
```
/var/lib/postgresql/data/pgdata/pg_ident.conf
```
3. Aggiungi include 'custom.conf' e include 'override.conf' alla fine del file:
```
echo "include 'custom.conf'" >> postgresql.conf
echo "include 'override.conf'" >> postgresql.conf
```
Riavvia il pod. Dopo l'avvio del pod, tutti i pod vengono replicati dal primo pod.

Utilizza il nuovo cnpg-cluster.

Disabilita il cluster di replica:

Modifica il cnpg-postgres.yaml file:

........
replica:
enabled: false
source: zalando-postgres
..........

Riapplicare il cnpg-postgres.yaml file:

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

Connettiti al database:
```
psql -U postgres
```

Aggiorna la versione di collazione:

ALTER DATABASE template1 REFRESH COLLATION VERSION;

Aggiorna la configurazione delle specifiche di base:

Nel file Instana Core, aggiornare la postgresConfig configurazione come mostrato nell'esempio seguente:

.....................
postgresConfigs:
  - authEnabled: true
     hosts:
       - postgres-rw.instana-postgres-01
.....................

Riapplicare il core.yaml file:

kubectl apply -f core.yaml -n instana-core