- v1.12 (più recente)
- Versione 1.11
- Versione 1.10
- Elenco delle versioni supportate
- Versione 1.9
- Versione 1.8
- Versione 1.7
- Versione 1.6
- Versione 1.5
- Versione 1.4
- Versione 1.3
- Versione 1.2
- Versione 1.1
Versioni supportate:
Versioni non supportate:
Conservare i segreti di Cassandra in Hashicorp Vault
Questa funzionalità consente di archiviare le credenziali Cassandra DB per Apigee Hybrid in Hashicorp Vault, un gestore di secret esterno. I gestori dei secret esterni consentono di gestire il modo in cui i secret vengono archiviati in Kubernetes, tra cui la gestione della residenza dei dati e dei controlli dell'accesso granulari.
Prima di Apigee versione 1.10 di ibrida, l'unico modo per fornire password per gli utenti Cassandra era specificare la password in override.yaml. Queste password sono archiviate nei secret di Kubernetes. Ad esempio:
cassandra: auth: default: password: "********" admin: password: "********" ddl: password: "********" dml: password: "********" jmx: username: "jmxuser" password: "********" jolokia: username: "apigee" password: "********"
Utilizzando Hashicorp Vault, puoi fornire queste password tramite l'API CSI Driver di Kubernetes Secrets Store
(SecretProviderClass
).
In questo modo Kubernetes può montare più secret, chiavi e certificati archiviati in un Vault esterno.
Utenti e password di Cassandra
Dovrai creare secret per i seguenti utenti Cassandra. Modifica i valori predefiniti in modo che soddisfino i criteri di sicurezza della tua organizzazione.
Utente Cassandra | Nome utente predefinito | Password predefinita |
---|---|---|
Amministratore | admin_user |
"********" |
DDL | ddl_user |
"********" |
Predefinito | cassandra Nota: il nome utente predefinito deve essere sempre "cassandra" |
"********" |
DML | dml_user |
"********" |
JMX | "jmxuser" |
"********" |
Jolokia | "apigee" |
"********" |
Per ulteriori informazioni, consulta la proprietà di configurazione cassandra.
Configura l'integrazione di secret esterni
La configurazione dell'integrazione di Vault per Apigee hybrid prevede le seguenti procedure.
- Nelle prime due procedure devi interagire direttamente con Vault.
- Nella terza e nella quarta procedura applicherai le configurazioni al cluster Kubernetes.
Utilizza le seguenti procedure per creare i secret in Vault e consentire all'installazione ibrida di accedervi.
Creare secret, criteri e ruoli in Vault
-
Verifica che il contesto Kubernetes attuale sia impostato sul tuo cluster:
kubectl config current-context
-
Utilizza l'API, l'interfaccia a riga di comando o la UI di Vault per creare i secret di cassandra. I valori del secret che crei devono corrispondere ai nomi utente e alle password Cassandra attualmente utilizzati nel cluster.
-
Chiave segreta: è possibile utilizzare qualsiasi chiave segreta (o combinazione di più chiavi), ad esempio:
secret/data/apigee/cassandra
-
Dati secret: Apigee Hybrid richiede le coppie di nome utente e password per i seguenti utenti Cassandra:
Utenti Cassandra Amministratore DDL Predefinito DML JMX Jolokia -
Interfaccia a riga di comando di Vault: il comando seguente mostra come creare un singolo secret contenente tutti i nomi utente e le password richiesti:
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"
I nomi utente predefiniti per ciascun utente sono i seguenti:Utente Cassandra Valore predefinito Amministratore admin_user
DDL ddl_user
Predefinito cassandra
DML dml_user
JMX jmxuser
Jolokia apigee
-
Chiave segreta: è possibile utilizzare qualsiasi chiave segreta (o combinazione di più chiavi), ad esempio:
-
In Vault, crea un criterio per concedere l'accesso al secret che hai appena creato.
-
Crea un file di criteri (nome suggerito:
apigee-cassandra-auth.txt
) con i contenuti seguenti:path "secret/data/apigee/cassandra" { capabilities = ["read"] }
Se hai creato più secret, ogni secret deve essere aggiunto al file dei criteri:path "secret/data/apigee/cassandra/admin" { capabilities = ["read"] } path "secret/data/apigee/cassandra/ddl" { capabilities = ["read"] }
-
Applica il criterio a Vault:
vault policy write apigee-cassandra-auth apigee-cassandra-auth.txt
È possibile creare il criterio utilizzando l'input standard anziché leggere da un file:
echo 'path "secret/data/apigee/cassandra" { capabilities = ["read"] }' | vault policy write apigee-cassandra-auth -
-
Crea un file di criteri (nome suggerito:
-
Associa il criterio agli account di servizio Kubernetes di Apigee Cassandra.
- Definisci le seguenti variabili di ambiente:
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}
Dove:
- ORG_NAME è il nome della tua organizzazione Apigee.
- ENVS_LIST è un elenco separato da virgole dei tuoi ambienti Apigee, ad
esempio
dev,prod
. - APIGEE_NAMESPACE è lo spazio dei nomi Apigee. Il valore predefinito è
apigee
. - NAMESPACES è un elenco separato da virgole di spazi dei nomi per Apigee,
apigee-system
e lo spazio dei nomi Apigee.
- Crea uno script con i contenuti seguenti. Lo script può avere qualsiasi nome. Nell'esempio seguente, il nome dello script è
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
- Esegui lo script e assegna l'output alla variabile SERVICE_ACCOUNT_NAMES.
Verrà creato un elenco separato da virgole di nomi degli account di servizio Kubernetes.
export SERVICE_ACCOUNT_NAMES=$(./create-vault-cassandra-role)
Verifica che la variabile sia stata compilata con l'elenco:
echo $SERVICE_ACCOUNT_NAMES
-
Utilizza l'interfaccia a riga di comando di Vault per creare un ruolo che associa il criterio agli account di servizio 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
- Definisci le seguenti variabili di ambiente:
Installa il driver CSI e il provider di Vault
Apigee hybrid v1.12.0 supporta le seguenti versioni dei grafici Helm:
Software | Versione |
---|---|
Driver CSI dell'archivio secret | v1.3.4 |
Vault | v0.25.0 |
- Segui le istruzioni di installazione del driver CSI dell'archivio secret per installare il driver CSI sul cluster. Il driver CSI dispone di un grafico Helm per l'installazione.
- Segui le istruzioni riportate in Installazione del provider CSI di Vault per installare il provider CSI di Vault, se non l'hai già installato.
Crea oggetto SecretProviderClass
La risorsa SecretProviderClass
indica al driver CSI con quale provider comunicare quando vengono richiesti i secret. Le credenziali degli utenti Cassandra devono essere configurate
tramite questo oggetto. La tabella seguente mostra i nomi di file (objectName
) previsti da Apigee Cassandra:
Utente Cassandra | Nomi dei file secret previsti |
---|---|
Amministratore | adminUsername , adminPassword |
DDL | ddlUsername , ddlPassword |
Predefinito | cassandra , defaultPassword |
DML | dmlUsername , dmlPassword |
JMX | jmxUsername , jmxPassword |
Jolokia | jolokiaUsername , jolokiaPassword |
- Crea un file YAML per
SecretProviderClass
. Il nome del file può essere qualsiasi, ad esempio:spc.yaml
. Usa il seguente modelloSecretProviderClass
per configurare questa risorsa: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: ""
- Applica
SecretProviderClass
a entrambi gli spazi dei nomiapigee
eapigee-system
. Nei comandi seguenti, gli spazi dei nomi sonoapigee
eapigee-system
. Sostituisci questi valori se utilizzi spazi dei nomi diversi:kubectl -n apigee apply -f spc.yaml
kubectl -n apigee-system apply -f spc.yaml
Abilita il secret esterno per Cassandra
- All'interno di
overrides.yaml
, aggiungi la configurazione seguente per abilitare l'utilizzo dei secret esterni per Cassandra:cassandra: auth: secretProviderClass: apigee-cassandra-auth-spc # The name of the SecretProviderClass created in spc.yaml.
- Utilizza
helm upgrade
per applicare la modifica ai componentiapigee-operator
eapigee-datastore
:- Il controller del datastore in
apigee-operator
partecipa al ritiro e alla replica dei dati di Cassandra durante l'espansione della regione. Queste attività richiedono le credenziali JMX e Jolokia.helm upgrade operator apigee-operator/ \ --namespace apigee-system \ --atomic \ -f overrides.yaml
apigee-datastore
fornisce le credenziali che i componenti downstream comeapigee-runtime
, il sincronizzatore e MART utilizzano per la connessione a Cassandra.helm upgrade datastore apigee-datastore/ \ --namespace apigee \ --atomic \ -f overrides.yaml
- Il controller del datastore in
-
Verifica che vengano utilizzati secret esterni. Quando i secret esterni sono abilitati, vengono aggiunti nuovi
Volume
,Volume Mount
eEnvironment Variable
facendo riferimento ai secret.- Verifica il deployment di
apigee-controller-manager
.Verifica che esista un
Volume
denominatoapigee-external-secrets
e faccia riferimento alSecretProviderClass
creato in precedenza: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" }
Controlla che esista un
VolumeMount
denominatoapigee-external-secrets
: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 }
Verifica che esistano
Environment Variable
che fanno riferimento a secret esterni: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" } ]
- Verifica il deployment di
Rollback al secret di K8s
- Per ripristinare i secret non esterni, rimuovi la configurazione
secretProviderClass
inoverrides.yaml
e utilizza la configurazione precedente:cassandra: auth: secretProviderClass: apigee-cassandra-auth-spc # remove this line
- Utilizza
helm upgrade
per applicare la modifica ai componentiapigee-operator
eapigee-datastore
:helm upgrade operator apigee-operator/ \ --namespace apigee-system \ --atomic \ -f overrides.yaml
helm upgrade datastore apigee-datastore/ \ --namespace apigee \ --atomic \ -f overrides.yaml
Risoluzione dei problemi: creazione di un contenitore client per il debug
Se utilizzi Vault, questa sezione sostituisce le istruzioni riportate nella sezione relativa alla risoluzione dei problemi, Creare un contenitore client per il debug.
Questa sezione spiega come creare un container client da cui accedere alle utilità di debug di Cassandra, come cqlsh
. Queste utilità consentono di eseguire query sulle tabelle Cassandra e possono essere utili per il debug.
Crea il contenitore client
Per creare il contenitore client:
- Il container utilizza il certificato TLS del pod
apigee-cassandra-user-setup
. Il primo passaggio consiste nel recuperare il nome di questo certificato:kubectl get secrets -n apigee --field-selector type=kubernetes.io/tls | grep apigee-cassandra-user-setup | awk '{print $1}'
Questo comando restituisce il nome del certificato. Ad esempio:
apigee-cassandra-user-setup-rg-hybrid-b7d3b9c-tls
. - Apri un nuovo file e incolla al suo interno le seguenti specifiche del pod:
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.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
- Salva il file con un'estensione
.yaml
. Ad esempio:my-spec.yaml
. - Applica la specifica al cluster:
kubectl apply -f my-spec.yaml -n apigee
- Accedi al container:
kubectl exec -n CASSANDRA_CLIENT_NAME -it -- bash
- Connettiti all'interfaccia
cqlsh
di Cassandra con i seguenti comandi. Inserisci i comandi esattamente come mostrato: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
Eliminazione del pod client
Utilizza questo comando per eliminare il pod del client Cassandra:
kubectl delete pods -n apigee cassandra-client