Halaman ini diterjemahkan oleh Cloud Translation API.

Menyimpan rahasia Cassandra di Hashicorp Vault

Fitur ini memungkinkan Anda menyimpan kredensial Cassandra DB untuk Apigee Hybrid di Hashicorp Vault, pengelola rahasia eksternal. External secret manager dapat Anda gunakan untuk mengelola cara secret disimpan di Kubernetes, termasuk pengelolaan residensi data dan kontrol akses terperinci.

Sebelum Apigee Hybrid versi 1.10, satu-satunya cara untuk menyediakan sandi bagi pengguna Cassandra adalah dengan menentukan sandi di override.yaml. Sandi ini disimpan dalam secret Kubernetes. Contoh:

cassandra:
  auth:
    default:
      password: "********"
    admin:
      password: "********"
    ddl:
      password: "********"
    dml:
      password: "********"
    jmx:
      username: "jmxuser"
      password: "********"
    jolokia:
      username: "apigee"
      password: "********"

Dengan menggunakan Hashicorp Vault, Anda dapat menyediakan sandi ini melalui Kubernetes Secrets Store CSI Driver API (SecretProviderClass). Hal ini memungkinkan Kubernetes untuk memasang beberapa secret, kunci, dan sertifikat yang disimpan di Vault eksternal.

Pengguna dan sandi Cassandra

Anda harus membuat secret untuk pengguna Cassandra berikut. Ubah nilai default agar memenuhi kebijakan keamanan organisasi Anda.

Catatan: Anda menetapkan nama pengguna Cassandra saat pertama kali menginstal Apigee Hybrid. Anda tidak dapat mengubahnya setelah itu. Nama pengguna Default harus selalu "cassandra".

Pengguna Cassandra	Nama pengguna default	Sandi default
Admin	`admin_user`	`"********"`
DDL	`ddl_user`	`"********"`
Default	`cassandra` Catatan: Nama pengguna default harus selalu "cassandra"	`"********"`
DML	`dml_user`	`"********"`
JMX	`"jmxuser"`	`"********"`
Jolokia	`"apigee"`	`"********"`

Lihat properti konfigurasi cassandra untuk informasi selengkapnya.

Mengonfigurasi integrasi secret eksternal

Catatan: Apigee Hybrid hanya mendukung integrasi Vault menggunakan pengelolaan Helm. Jika Anda menggunakan apigeectl untuk mengelola penginstalan hybrid, lihat Memigrasikan Apigee Hybrid ke Helm dari apigeectl.

Penyiapan integrasi Vault untuk Apigee Hybrid terdiri dari prosedur berikut.

Dalam dua prosedur pertama, Anda berinteraksi langsung dengan Vault.
Pada prosedur ketiga dan keempat, Anda akan menerapkan konfigurasi ke cluster Kubernetes.

Gunakan prosedur berikut untuk membuat rahasia di Vault dan memungkinkan penginstalan hybrid Anda agar memiliki akses ke rahasia tersebut.

Membuat rahasia, kebijakan, dan peran Vault

Pastikan konteks Kubernetes saat ini ditetapkan ke cluster Anda:
```
kubectl config current-context
```

Gunakan Vault API, CLI, atau UI untuk membuat secret cassandra. Nilai rahasia yang Anda buat harus cocok dengan nama pengguna dan sandi Cassandra yang saat ini digunakan di cluster Anda.

Kunci rahasia: Semua kunci rahasia (atau kombinasi beberapa kunci) dapat digunakan, misalnya:
```
secret/data/apigee/cassandra
```

Data rahasia: Apigee Hybrid mengharapkan pasangan nama pengguna dan sandi untuk pengguna Cassandra berikut:

Pengguna Cassandra
Admin
DDL
Default
DML
JMX
Jolokia

Nilai nama pengguna dan sandi ini dapat tersebar di berapa pun kunci rahasia.

Vault CLI: Perintah berikut menunjukkan cara membuat satu rahasia yang berisi semua nama pengguna dan sandi yang diperlukan:

vault kv put secret/apigee/cassandra \
    adminUsername="ADMIN_USERNAME" \
    adminPassword="ADMIN_PASSWORD" \
    ddlUsername="DDL_USERNAME" \
    ddlPassword="DDL_PASSWORD" \
    defaultUsername="cassandra" \
    defaultPassword="DEFAULT_PASSWORD" \
    dmlUsername="DML_USERNAME" \
    dmlPassword="DML_PASSWORD" \
    jmxUsername="JMX_USERNAME" \
    jmxPassword="JMX_PASSWORD" \
    jolokiaUsername="JOLOKIA_USERNAME" \
    jolokiaPassword="JOLOKIA_PASSWORD"

Catatan: data/ tidak boleh disertakan dalam kunci rahasia saat menjalankan perintah ini. Vault akan menyisipkannya secara otomatis.

Nama pengguna default untuk setiap pengguna adalah sebagai berikut:

Pengguna Cassandra	Nilai default
Admin	`admin_user`
DDL	`ddl_user`
Default	`cassandra`
DML	`dml_user`
JMX	`jmxuser`
Jolokia	`apigee`

Tips: Anda dapat melihat sandi default di file values.yaml di direktori diagram apigee-datastore/.

Di dalam Vault, buat kebijakan untuk memberikan akses ke rahasia yang baru saja Anda buat.
1. Buat file kebijakan (nama yang disarankan: apigee-cassandra-auth.txt) dengan konten berikut:
```
path "secret/data/apigee/cassandra" {
  capabilities = ["read"]
}
```
  Jika Anda membuat beberapa secret, setiap secret harus ditambahkan ke file kebijakan:
```
path "secret/data/apigee/cassandra/admin" {
  capabilities = ["read"]
}

path "secret/data/apigee/cassandra/ddl" {
  capabilities = ["read"]
}
```
  Catatan: Jangan lupakan data/ di jalur (misalnya secret/data/apigee/cassandra).
2. Terapkan kebijakan ke Vault:
```
vault policy write apigee-cassandra-auth apigee-cassandra-auth.txt
```
  Anda dapat membuat kebijakan menggunakan input standar, bukan membaca dari file:
```
echo 'path "secret/data/apigee/cassandra" { capabilities = ["read"] }' | vault policy write apigee-cassandra-auth -
```
  Catatan: apigee-cassandra-auth adalah nama kebijakan. Nilai apa pun dapat digunakan, tetapi nilai persis ini harus ditentukan saat mengikat kebijakan ke akun layanan Kubernetes di langkah berikutnya.

Ikat kebijakan ke akun layanan Apigee Cassandra Kubernetes.

Tentukan variabel lingkungan berikut:
```
export ORG_NAME=APIGEE_ORG_NAME
export ENVS_LIST=LIST_OF_APIGEE-ENVS
export APIGEE_NAMESPACE=YOUR_APIGEE_NAMESPACE
export NAMESPACES=apigee-system,${APIGEE_NAMESPACE}
```
Dengan keterangan:
- ORG_NAME adalah nama organisasi Apigee Anda.
- ENVS_LIST Adalah daftar yang dipisahkan koma dari lingkungan Apigee Anda, misalnya dev,prod.
- APIGEE_NAMESPACE adalah namespace Apigee Anda. Defaultnya adalah apigee.
- NAMESPACES adalah daftar namespace yang dipisahkan koma untuk Apigee, apigee-system, dan namespace Apigee Anda.

Buat skrip dengan konten berikut. Skrip dapat menggunakan nama apa pun. Dalam contoh berikut, nama skripnya adalah create-vault-cassandra-role.sh:

# create-vault-cassandra-role.sh

ORG=ORG_NAME  # ORG name
ENVS=ENVS_LIST # comma separated env names, for example: dev,prod

org_short_name=$(echo $ORG | head -c 15)
encode=$(echo -n $ORG | shasum -a 256 | head -c 7)
org_encode=$(echo "$org_short_name-$encode")
names=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${org_encode},apigee-cassandra-schema-val-${org_encode},apigee-cassandra-user-setup-${org_encode},apigee-mart-${org_encode},apigee-mint-task-scheduler-${org_encode}

for env in ${ENVS//,/ }
do
  env_short_name=$(echo $env | head -c 15)
  encode=$(echo -n $ORG:$env | shasum -a 256 | head -c 7)
  env_encode=$(echo "$org_short_name-$env_short_name-$encode")
  names+=,apigee-synchronizer-${env_encode},apigee-runtime-${env_encode}
done

echo $names

Jalankan skrip dan tetapkan output ke variabel SERVICE_ACCOUNT_NAMES. Tindakan ini akan membuat daftar nama akun layanan Kubernetes yang dipisahkan koma.
```
export SERVICE_ACCOUNT_NAMES=$(./create-vault-cassandra-role)
```
Catatan: Anda mungkin perlu melakukan chmod pada skrip sebelum menjalankannya.

Pastikan variabel telah diisi dengan daftar:
```
echo $SERVICE_ACCOUNT_NAMES
```
Gunakan Vault CLI untuk membuat peran yang mengikat kebijakan ke akun layanan Kubernetes:
```
vault write auth/kubernetes/role/cassandra \
    bound_service_account_names=${SERVICE_ACCOUNT_NAMES} \
    bound_service_account_namespaces=${NAMESPACES} \
    policies=apigee-cassandra-auth \
    ttl=1m
```
Catatan: Nama kebijakan harus cocok dengan nama yang dibuat di langkah sebelumnya (misalnya, apigee-cassandra-auth).

Instal driver CSI dan penyedia Vault

Apigee hybrid v1.12.1 mendukung versi chart Helm berikut:

Software	Version
Driver CSI Toko Rahasia	v1.3.4
Vault	v0.25.0

Ikuti petunjuk penginstalan Driver Secrets Store CSI untuk Menginstal driver CSI pada cluster. Driver CSI memiliki chart Helm untuk penginstalan.
Catatan: Pada penginstalan OpenShift, berikan akses istimewa ke akun layanan secrets-store-csi-driver dengan perintah berikut:
```
oc adm policy add-scc-to-user privileged system:serviceaccount:"${NAMESPACE}":secrets-store-csi-driver
```
Dengan NAMESPACE adalah namespace tempat Anda menginstal driver CSI.
Ikuti petunjuk di Menginstal penyedia Vault CSI untuk menginstal penyedia Vault CSI jika Anda belum menginstalnya.
Catatan: Untuk penginstalan pada OpenShift, ikuti prosedur dalam Penginstalan di OpenShift.
- Untuk KUBERNETES_APPLICATION_NAMESPACE, berikan namespace tempat Anda menginstal Vault.
- Untuk APPLICATION_SERVICE_ACCOUNT, berikan nama akun layanan Kubernetes untuk Vault. Biasanya vault-csi-provider. Anda dapat memeriksa nama akun layanan dengan perintah berikut:
```
kubectl -n KUBERNETES_APPLICATION_NAMESPACE get ds vault-csi-provider -oyaml | grep 'serviceAccountName'
```
```
      serviceAccountName: vault-csi-provider
```

Membuat objek SecretProviderClass

Resource SecretProviderClass memberi tahu driver CSI mengenai penyedia yang harus berkomunikasi saat meminta secret. Kredensial pengguna Cassandra harus dikonfigurasi melalui objek ini. Tabel berikut menunjukkan nama file (objectName) yang diharapkan oleh Apigee Cassandra:

Pengguna Cassandra	Nama file secret yang diharapkan
Admin	`adminUsername`, `adminPassword`
DDL	`ddlUsername`, `ddlPassword`
Default	`cassandra`, `defaultPassword`
DML	`dmlUsername`, `dmlPassword`
JMX	`jmxUsername`, `jmxPassword`
Jolokia	`jolokiaUsername`, `jolokiaPassword`

Buat file YAML untuk SecretProviderClass. Nama file dapat berupa apa pun, misalnya: spc.yaml. Gunakan template SecretProviderClass berikut untuk mengonfigurasi resource ini:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-cassandra-auth-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-cassandra-auth  # the roleName should match the vault role you created earlier in this procedure

    # vaultAddress is the endpoint your Vault server is running at.
    # If Vault is running in the same cluster as Apigee, the format will generally be:
    # http://vault.<namespace>.svc.cluster.local:<vaultServicePort>
    vaultAddress: VAULT_ADDRESS

    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Cassandra expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
    # For example, if the Vault secret is located at `secret/data/apigee/cassandra`
    # and you want to specify the admin password, you would use the following:
    # - objectName: "adminPassword"
    #   secretPath: "secret/data/apigee/cassandra"
    #   secretKey: "key within Vault secret specifying the admin password"
    objects: |
      - objectName: "adminUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "adminPassword"
        secretPath: ""
        secretKey: ""
      - objectName: "defaultUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "defaultPassword"
        secretPath: ""
        secretKey: ""
      - objectName: "ddlUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "ddlPassword"
        secretPath: ""
        secretKey: ""
      - objectName: "dmlUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "dmlPassword"
        secretPath: ""
        secretKey: ""
      - objectName: "jolokiaUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "jolokiaPassword"
        secretPath: ""
        secretKey: ""
      - objectName: "jmxUsername"
        secretPath: ""
        secretKey: ""
      - objectName: "jmxPassword"
        secretPath: ""
        secretKey: ""

Terapkan SecretProviderClass ke namespace apigee dan apigee-system Anda. Dalam perintah berikut, namespace adalah apigee dan apigee-system. Ganti nilai tersebut jika Anda menggunakan namespace yang berbeda:
```
kubectl -n apigee apply -f spc.yaml
kubectl -n apigee-system apply -f spc.yaml
```

Aktifkan secret eksternal untuk Cassandra

Dalam overrides.yaml Anda, tambahkan konfigurasi berikut guna mengaktifkan penggunaan secret eksternal untuk Cassandra:
```
cassandra:
  auth:
    secretProviderClass: apigee-cassandra-auth-spc  # The name of the SecretProviderClass created in spc.yaml.
```
Catatan: Nama yang Anda berikan untuk cassandra.auth.secretProviderClass harus cocok dengan nama SecretProviderClass yang Anda buat di file spc.yaml pada langkah sebelumnya.

Lihat cassandra.auth.secretProviderClass.
Gunakan helm upgrade untuk menerapkan perubahan pada komponen apigee-operator dan apigee-datastore:
- Pengontrol datastore di apigee-operator berpartisipasi dalam penghentian Cassandra dan replikasi data selama perluasan region. Tugas ini memerlukan kredensial JMX dan Jolokia.
```
helm upgrade operator apigee-operator/ \
  --namespace apigee-system \
  --atomic \
  -f overrides.yaml
```
- apigee-datastore menyediakan kredensial yang digunakan komponen downstream seperti apigee-runtime, Synchronizer & MART saat terhubung ke Cassandra.
```
helm upgrade datastore apigee-datastore/ \
  --namespace apigee \
  --atomic \
  -f overrides.yaml
```

Memverifikasi bahwa secret eksternal digunakan. Jika secret eksternal diaktifkan, Volume, Volume Mount, dan Environment Variable baru akan ditambahkan dengan merujuk pada secret tersebut.

Verifikasi deployment apigee-controller-manager.

Pastikan Volume bernama apigee-external-secrets ada dan merujuk ke SecretProviderClass yang dibuat di atas:

kubectl -n apigee-system get deployment apigee-controller-manager -o jsonpath='{.spec.template.spec.volumes[?(@.name=="apigee-external-secrets")]}'
{
  "csi": {
    "driver": "secrets-store.csi.k8s.io",
    "readOnly": true,
    "volumeAttributes": {
      "secretProviderClass": "apigee-cassandra-auth-spc"
    }
  },
  "name": "apigee-external-secrets"
}

Pastikan bahwa VolumeMount bernama apigee-external-secrets sudah ada:

kubectl -n apigee-system get deployment apigee-controller-manager -o jsonpath='{.spec.template.spec.containers[?(@.name=="manager")].volumeMounts[?(@.name=="apigee-external-secrets")]}'
{
  "mountPath": "/opt/apigee/externalsecrets",
  "name": "apigee-external-secrets",
  "readOnly": true
}

Pastikan ada Environment Variable yang mereferensikan rahasia eksternal:

kubectl -n apigee-system get deployment apigee-controller-manager -o jsonpath='{.spec.template.spec.containers[?(@.name=="manager")].env}'
[
  ...
  {
    "name": "CASSANDRA_JOLOKIA_USERNAME_PATH",
    "value": "/opt/apigee/externalsecrets/jolokiaUsername"
  },
  {
    "name": "CASSANDRA_JOLOKIA_PASSWORD_PATH",
    "value": "/opt/apigee/externalsecrets/jolokiaPassword"
  }
]

Rollback ke Rahasia K8s

Untuk mengembalikan ke secret non-eksternal, hapus konfigurasi secretProviderClass di overrides.yaml dan gunakan konfigurasi sebelumnya:
```
cassandra:
      auth:
        secretProviderClass: apigee-cassandra-auth-spc # remove this line
```

Gunakan helm upgrade untuk menerapkan perubahan pada komponen apigee-operator dan apigee-datastore:

helm upgrade operator apigee-operator/ \
  --namespace apigee-system \
  --atomic \
  -f overrides.yaml

helm upgrade datastore apigee-datastore/ \
  --namespace apigee \
  --atomic \
  -f overrides.yaml

Pemecahan masalah: Membuat penampung klien untuk proses debug

Jika Anda menggunakan Vault, bagian ini akan menggantikan petunjuk di bagian pemecahan masalah, Membuat penampung klien untuk proses debug.

Bagian ini menjelaskan cara membuat penampung klien yang dapat digunakan untuk mengakses utilitas proses debug Cassandra seperti cqlsh. Utilitas ini memungkinkan Anda membuat kueri tabel Cassandra dan dapat berguna untuk tujuan proses debug.

Membuat penampung klien

Untuk membuat penampung klien, ikuti langkah-langkah berikut:

Container menggunakan sertifikat TLS dari pod apigee-cassandra-user-setup. Langkah pertama adalah mengambil nama sertifikat ini:
```
kubectl get secrets -n apigee --field-selector type=kubernetes.io/tls | grep apigee-cassandra-user-setup | awk '{print $1}'
```
Perintah ini akan menampilkan nama sertifikat. Misalnya: apigee-cassandra-user-setup-rg-hybrid-b7d3b9c-tls.

Buka file baru dan tempelkan spesifikasi pod berikut ke dalamnya:

apiVersion: v1
  kind: Pod
  metadata:
    labels:
    name: CASSANDRA_CLIENT_NAME   # For example: my-cassandra-client
    namespace: apigee
  spec:
    containers:
    - name: CASSANDRA_CLIENT_NAME
      image: "gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra-client:1.12.1"
      imagePullPolicy: Always
      command:
      - sleep
      - "3600"
      env:
      - name: CASSANDRA_SEEDS
        value: apigee-cassandra-default.apigee.svc.cluster.local
      - name: APIGEE_DML_USERNAME_PATH
        value: /opt/apigee/externalsecrets/dmlUsername
      - name: APIGEE_DML_PASSWORD_PATH
        value: /opt/apigee/externalsecrets/dmlPassword
      volumeMounts:
      - mountPath: /opt/apigee/ssl
        name: tls-volume
        readOnly: true
      - name: apigee-external-secrets
        mountPath: /opt/apigee/externalsecrets
        readOnly: true
    volumes:
    - name: tls-volume
      secret:
        defaultMode: 420
        secretName: apigee-cassandra-user-setup-vaibhavhybridor-8b3e61d-tls
    - name: apigee-external-secrets
      csi:
        driver: secrets-store.csi.k8s.io
        readOnly: true
        volumeAttributes:
          secretProviderClass: apigee-cass-password
    serviceAccount: apigee-cassandra-default
    serviceAccountName: apigee-cassandra-default
    restartPolicy: Never

Simpan file dengan ekstensi .yaml. Contoh: my-spec.yaml.
Terapkan spesifikasi ke cluster Anda:
```
kubectl apply -f my-spec.yaml -n apigee
```

kubectl exec -n CASSANDRA_CLIENT_NAME -it -- bash

Hubungkan ke antarmuka cqlsh Cassandra dengan perintah berikut. Masukkan perintah persis seperti yang ditunjukkan:

APIGEE_DML_USER=$(cat "$APIGEE_DML_USERNAME_PATH")
export APIGEE_DML_USER
APIGEE_DML_PASSWORD=$(cat "$APIGEE_DML_PASSNAME_PATH")
export APIGEE_DML_PASSWORD
cqlsh ${CASSANDRA_SEEDS} -u ${APIGEE_DML_USER} -p ${APIGEE_DML_PASSWORD} --ssl

Menghapus pod klien

Gunakan perintah ini untuk menghapus pod klien Cassandra:

kubectl delete pods -n apigee cassandra-client