Menyimpan secret Cassandra di Hashicorp Vault

Menyimpan secret Cassandra di Hashicorp Vault

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

Sebelum Apigee hybrid versi 1.10, satu-satunya cara untuk memberikan sandi bagi pengguna Cassandra adalah dengan menentukan sandi di overrides.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 memberikan sandi ini melalui Kubernetes Secrets Store CSI Driver API (SecretProviderClass). Hal ini memungkinkan Kubernetes 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 sesuai dengan kebijakan keamanan organisasi Anda.

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 mengetahui informasi selengkapnya.

Mengonfigurasi integrasi secret eksternal

Penyiapan integrasi Vault untuk Apigee Hybrid terdiri dari prosedur berikut.

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

Gunakan prosedur berikut untuk membuat secret di Vault dan mengaktifkan penginstalan hybrid Anda agar dapat mengaksesnya.

Membuat secret, kebijakan, dan peran Vault

  1. Pastikan konteks Kubernetes saat ini disetel ke cluster Anda:
    kubectl config current-context
  2. Gunakan Vault API, CLI, atau UI untuk membuat secret cassandra. Nilai secret yang Anda buat harus cocok dengan nama pengguna dan sandi Cassandra yang saat ini digunakan di cluster Anda.
    • Kunci secret: Kunci secret apa pun (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 sejumlah kunci rahasia.
    • Vault CLI: Perintah berikut menunjukkan cara membuat satu secret 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"
      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
  3. Dalam Vault, buat kebijakan untuk memberikan akses ke secret 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"]
      }
    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 -
  4. Ikat kebijakan ke akun layanan Kubernetes Cassandra Apigee.
    1. Tentukan variabel lingkungan berikut:
      export ORG_NAME=APIGEE_ORG_NAME
      export ENVS_LIST=LIST_OF_APIGEE-ENVS
      export APIGEE_NAMESPACE=YOUR_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.
    2. Buat skrip dengan konten berikut. Skrip dapat memiliki 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
      
    3. 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)

      Pastikan variabel diisi dengan daftar:

      echo $SERVICE_ACCOUNT_NAMES
    4. 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=${APIGEE_NAMESPACE} \
          policies=apigee-cassandra-auth \
          ttl=1m

Menginstal driver CSI dan penyedia Vault

Apigee hybrid v1.14.0 mendukung versi diagram Helm berikut:

Software Version
Driver CSI Secrets Store v1.4.1
Vault 1.15.2
  1. Ikuti petunjuk penginstalan Driver CSI Secrets Store untuk Menginstal driver CSI di cluster Anda. Driver CSI memiliki diagram Helm untuk penginstalan.
  2. Ikuti petunjuk di Menginstal penyedia CSI Vault untuk menginstal penyedia CSI Vault jika Anda belum menginstalnya.

Membuat objek SecretProviderClass

Resource SecretProviderClass memberi tahu driver CSI penyedia yang akan diajak 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 rahasia yang diharapkan
Admin adminUsername, adminPassword
DDL ddlUsername, ddlPassword
Default cassandra, defaultPassword
DML dmlUsername, dmlPassword
JMX jmxUsername, jmxPassword
Jolokia jolokiaUsername, jolokiaPassword
  1. Buat file YAML untuk SecretProviderClass Anda. Nama file dapat berupa apa saja, 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: ""
  2. Terapkan SecretProviderClass ke namespace apigee Anda:
    kubectl -n $APIGEE_NAMESPACE apply -f spc.yaml

Mengaktifkan secret eksternal untuk Cassandra

  1. Dalam overrides.yaml, tambahkan konfigurasi berikut untuk mengaktifkan penggunaan secret eksternal untuk Cassandra:
    cassandra:
      auth:
        secretProviderClass: apigee-cassandra-auth-spc  # The name of the SecretProviderClass created in spc.yaml.

    Lihat cassandra.auth.secretProviderClass.

  2. 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_NAMESPACE> \
        --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_NAMESPACE \
        --atomic \
        -f overrides.yaml
  3. Pastikan secret eksternal sedang digunakan. Saat secret eksternal diaktifkan, Volume, Volume Mount, dan Environment Variable baru akan ditambahkan yang mereferensikan secret.
    • Verifikasi deployment apigee-controller-manager.

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

      kubectl -n $APIGEE_NAMESPACE 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 VolumeMount bernama apigee-external-secrets ada:

      kubectl -n $APIGEE_NAMESPACE 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 Environment Variable ada yang mereferensikan secret eksternal:

      kubectl -n $APIGEE_NAMESPACE 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"
        }
      ]

Melakukan rollback ke Secret K8s

  1. Untuk kembali ke secret non-eksternal, hapus konfigurasi secretProviderClass di overrides.yaml dan gunakan konfigurasi sebelumnya:
    cassandra:
          auth:
            secretProviderClass: apigee-cassandra-auth-spc # remove this line
  2. Gunakan helm upgrade untuk menerapkan perubahan ke komponen apigee-operator dan apigee-datastore:
    helm upgrade operator apigee-operator/ \
      --namespace $APIGEE_NAMESPACE \
      --atomic \
      -f overrides.yaml
    helm upgrade datastore apigee-datastore/ \
      --namespace $APIGEE_NAMESPACE \
      --atomic \
      -f overrides.yaml

Pemecahan masalah: Membuat penampung klien untuk proses debug

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

Bagian ini menjelaskan cara membuat penampung klien tempat Anda dapat 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:

  1. Penampung menggunakan sertifikat TLS dari pod apigee-cassandra-user-setup. Langkah pertama adalah mengambil nama sertifikat ini:
    kubectl get secrets -n APIGEE_NAMESPACE --field-selector type=kubernetes.io/tls | grep apigee-cassandra-user-setup | awk '{print $1}'

    Perintah ini menampilkan nama sertifikat. Misalnya: apigee-cassandra-user-setup-rg-hybrid-b7d3b9c-tls.

  2. 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_NAMESPACE
      spec:
        containers:
        - name: CASSANDRA_CLIENT_NAME
          image: "gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra-client:1.14.0"
          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
  3. Simpan file dengan ekstensi .yaml. Contoh: my-spec.yaml.
  4. Terapkan spesifikasi ke cluster Anda:
    kubectl apply -f my-spec.yaml -n $APIGEE_NAMESPACE
  5. Login ke penampung:
    kubectl exec -n CASSANDRA_CLIENT_NAME -it -- bash
  6. Hubungkan ke antarmuka cqlsh Cassandra dengan perintah berikut. Masukkan perintah persis seperti yang ditampilkan:
    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_NAMESPACE cassandra-client