Esta página foi traduzida pela API Cloud Translation.

Armazenar dados num gestor de segredos externo

Este guia explica como armazenar e gerir os seguintes tipos de informações no serviço de armazenamento de segredos externo, Hashicorp Vault, em vez de no ficheiro overrides.yaml.

AX Hash Salt
Palavra-passe do Redis
Chaves de encriptação

Para armazenar outros tipos de informações no Vault, consulte:

Pré-requisitos

Um controlador CSI de armazenamento de segredos do Kubernetes. Pode instalá-lo seguindo as instruções em Secrets Store CSI Driver: Installation (Secrets Store CSI Driver: instalação). Para ver as versões suportadas, consulte o artigo Plataformas e versões suportadas do Apigee Hybrid: controlador CSI da Secret Store.
O fornecedor de CSI do Vault. Pode instalá-lo seguindo as instruções em Instalar o fornecedor de CSI do Vault. Para ver as versões suportadas, consulte o artigo Plataformas e versões suportadas do Apigee Hybrid: Vault.

Procedimento

Crie os segredos, as políticas e as funções do Vault.

Use a IU ou as APIs do Vault para criar segredos e conceder autorizações às contas de serviço do Kubernetes do Apigee para ler esses segredos, conforme descrito aqui. Os segredos têm de consistir numa chave e num ou mais valores, conforme mostrado na tabela seguinte:

Chave secreta	Dados secretos
`secret/data/apigee/axhashsalt`	{ "ax-hash-salt": "`AX_HASH_SALT_VALUE`" }
`secret/data/apigee/redis`	{ "redis-password": "`REDIS_PASSWORD_VALUE`" }
`secret/data/apigee/orgencryptionkeys`	{ "kmsEncryptionKey": "`KMS_ENCRYPTION_KEY_VALUE`" "kvmEncryptionKey": "`KVM_ENCRYPTION_KEY_VALUE`" "contractEncryptionKey": "`CONTRACT_ENCRYPTION_KEY_VALUE`" } Importante: o valor `contractEncryptionKey` tem de ser uma string codificada em base64 com um comprimento de 16, 24 ou 32 carateres. Consulte o artigo Encriptação de dados para mais informações.
`secret/data/apigee/envencryptionkeys`	{ "cacheEncryptionKey": "`CACHE_ENCRYPTION_KEY_VALUE`" "kvmEncryptionKey": "`KVM_ENCRYPTION_KEY_VALUE`" "envKvmEncryptionKey": "`ENV_KVM_ENCRYPTION_KEY_VALUE`" "kmsEncryptionKey": "`KMS_ENCRYPTION_KEY_VALUE`" }

No Vault, crie políticas que concedam acesso aos segredos:

cat axhashsalt-auth-policy.txt
path "secret/data/apigee/axhashsalt" {
  capabilities = ["read"]
}
cat redis-auth-policy.txt
path "secret/data/apigee/redis" {
  capabilities = ["read"]
}
cat orgencryptionkeys-auth-policy.txt
path "secret/data/apigee/orgencryptionkeys" {
  capabilities = ["read"]
}
cat envencryptionkeys-auth-policy.txt
path "secret/data/apigee/envencryptionkeys" {
  capabilities = ["read"]
}

vault policy write apigee-axhashsalt-auth axhashsalt-auth-policy.txt
vault policy write apigee-redis-auth redis-auth-policy.txt
vault policy write apigee-orgencryptionkeys-auth orgencryptionkeys-auth-policy.txt
vault policy write apigee-envencryptionkeys-auth envencryptionkeys-auth-policy.txt

Crie um script denominado generate-encoded-sas.sh com o seguinte conteúdo:

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_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-redis-default,apigee-redis-envoy-default,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-runtime-${ENV_ENCODE},apigee-synchronizer-${ENV_ENCODE}
done

echo $NAMES

Execute o script para gerar a lista de nomes de contas de serviço às quais associar as políticas:
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
A saída deve apresentar os nomes das contas de serviço codificados.

Usando as políticas, crie funções do Vault que associem as contas de serviço do Apigee necessárias.

vault write auth/kubernetes/role/apigee-axhashsalt \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-axhashsalt-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-redis \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-redis-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-orgencryptionkeys \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-orgencryptionkeys-auth \
	ttl=1m

vault write auth/kubernetes/role/apigee-envencryptionkeys \
	bound_service_account_names=BOUND_SA_NAMES \
	bound_service_account_namespaces=APIGEE_NAMESPACE \
	policies=apigee-envencryptionkeys-auth \
	ttl=1m

Crie objetos SecretProviderClass.

Adicione os seguintes segredos através dos SecretProviderClass recursos. Estes recursos indicam ao controlador CSI com que fornecedor comunicar quando pede segredos. A tabela seguinte mostra os nomes de ficheiros (objectNames) esperados pelo Apigee Hybrid:

Secreto	Nomes de ficheiros secretos esperados
AX Hash Salt	`ax-hash-salt`
Redis	`redis-password`
Chaves de encriptação da organização	`kmsEncryptionKey` `kvmEncryptionKey` `contractEncryptionKey`
Chaves de encriptação de ambiente	`kmsEncryptionKey` `kvmEncryptionKey` `envKvmEncryptionKey` `cacheEncryptionKey`

Use os seguintes modelos SecretProviderClass para configurar estes recursos:

# axhashsalt-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-axhashsalt-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-axhashsalt
    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 Hybrid 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.
    objects: |
      - objectName: "ax-hash-salt"
        secretPath: ""
        secretKey: ""

# redis-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-redis-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-redis
    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 Hybrid 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.
    objects: |
      - objectName: "redis-password"
        secretPath: ""
        secretKey: ""

# orgencryptionkeys-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgencryptionkeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgencryptionkeys
    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 Hybrid 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.
    objects: |
      - objectName: "kmsEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "contractEncryptionKey"
        secretPath: ""
        secretKey: ""

# envencryptionkeys-spc.yaml

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-envencryptionkeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-envencryptionkeys
    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 Hybrid 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.
    objects: |
      - objectName: "cacheEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "envKvmEncryptionKey"
        secretPath: ""
        secretKey: ""
      - objectName: "kmsEncryptionKey"
        secretPath: ""
        secretKey: ""

VAULT_ADDRESS é o ponto final onde o servidor do Vault está em execução. Se o Vault estiver a ser executado no mesmo cluster e espaço de nomes que o Apigee, o formato é geralmente http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Aplique o SecretProviderClasses acima ao espaço de nomes APIGEE_NAMESPACE:

kubectl -n APIGEE_NAMESPACE apply -f axhashsalt-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f redis-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f orgencryptionkeys-spc.yaml
kubectl -n APIGEE_NAMESPACE apply -f envencryptionkeys-spc.yaml

Ative o segredo externo para o AX Hash Salt.
1. No ficheiro overrides.yaml, adicione a seguinte configuração para ativar a utilização de segredos externos para o AX Hash Salt:
```
axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```
2. Aplique a alteração atualizando o org gráfico Helm:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Ative o segredo externo para a palavra-passe do Redis.
1. No ficheiro overrides.yaml, adicione a seguinte configuração para ativar a utilização de segredos externos para a palavra-passe do Redis:
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Em seguida, aplique as alterações atualizando os gráficos operator e redis pela seguinte ordem:
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Ative o segredo externo para as chaves de encriptação
1. No ficheiro overrides.yaml, adicione a seguinte configuração para ativar a utilização de segredos externos para as chaves de encriptação ao nível da organização:
```
encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```
2. Aplique a alteração atualizando o gráfico org Helm:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
3. No ficheiro overrides.yaml de cada ambiente, adicione a seguinte configuração para as chaves de encriptação específicas do ambiente:
```
envs:
- name: ENV_NAME
  encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```
4. Aplique a alteração atualizando o gráfico do env Helm uma vez para cada ambiente:
```
helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml
```

Reversão

AX Hash Salt

No ficheiro overrides.yaml, remova a configuração que ativou a utilização de segredos externos para o AX Hash Salt:
```
# Comment out or delete the following line:
# axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```

Aplique a alteração atualizando o org gráfico Helm:

helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml

Palavra-passe do Redis

No ficheiro overrides.yaml, remova a configuração que ativou a utilização de segredos externos para a palavra-passe do Redis:
```
redis:
  auth:
  # Comment out or delete the following line:
  # secretProviderClass: apigee-redis-spc
```

Em seguida, aplique as alterações atualizando os gráficos redis e operator pela seguinte ordem:

helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml

Chaves de encriptação

No ficheiro overrides.yaml, remova a configuração que ativou a utilização de segredos externos para as chaves de encriptação de variáveis de ambiente:
```
envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```

Aplique a alteração atualizando o gráfico do env Helm uma vez para cada ambiente:

helm upgrade ENV_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --set env=ENV_NAME \
  -f overrides.yaml

No ficheiro overrides.yaml, remova a configuração que ativou a utilização de segredos externos para as chaves de encriptação da organização:
```
# Comment out or delete the following line:
# encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```

Em seguida, atualize o orggráfico Helm:

helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml

Armazenar dados num gestor de segredos externo Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.