Esta página foi traduzida pela API Cloud Translation.

Como armazenar dados em um gerenciador de secrets externo

Este guia explica como armazenar e gerenciar os tipos de informações a seguir no serviço de armazenamento de secrets externos Hashicorp Vault, em vez de no arquivo overrides.yaml.

AX Hash Salt
Senha do Redis
Chaves de criptografia

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

Pré-requisitos

Um driver CSI de armazenamento de secrets do Kubernetes. Para fazer a instalação, siga as instruções em Driver CSI de armazenamento de secrets: instalação. Para conferir as versões compatíveis, consulte Plataformas e versões compatíveis com a Apigee híbrida: driver CSI de armazenamento de secrets.
O provedor CSI do Vault. Para fazer a instalação, siga as instruções em Como instalar o provedor CSI do Vault. Para conferir as versões compatíveis, consulte Plataformas e versões compatíveis com a Apigee híbrida: Vault.

Procedimento

Crie secrets, políticas e papéis do Vault.

Use as APIs ou a interface do Vault para criar secrets e conceder permissões às contas de serviço do Kubernetes da Apigee para ler esses secrets, conforme descrito aqui. Os secrets precisam consistir em uma chave e um ou mais valores, conforme mostrado na seguinte tabela:

Chave secreta	Dados do secret
`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` precisa ser uma string codificada em base64 com um comprimento de 16, 24 ou 32 caracteres. Consulte Criptografia 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 secrets:

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 chamado 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 a que as políticas serão vinculadas:
```
chmod +x ./generate-encoded-sas.sh
./generate-encoded-sas.sh
```
A saída vai listar os nomes das contas de serviço codificadas.

Usando as políticas, crie papéis do Vault que vinculem as contas de serviço necessárias da Apigee.

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

Criar objetos SecretProviderClass.

Adicione os seguintes secrets pelos recursos SecretProviderClass. Esses recursos informam ao driver CSI com qual provedor se comunicar ao solicitar secrets. A seguinte tabela mostra os nomes dos arquivos (objectNames) esperados pela Apigee híbrida:

Secret	Nomes de arquivos de secrets esperados
AX Hash Salt	`ax-hash-salt`
Redis	`redis-password`
Chaves de criptografia da organização	`kmsEncryptionKey` `kvmEncryptionKey` `contractEncryptionKey`
Chaves de criptografia do ambiente	`kmsEncryptionKey` `kvmEncryptionKey` `envKvmEncryptionKey` `cacheEncryptionKey`

Use os seguintes modelos de SecretProviderClass para configurar os 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 endpoint em que o servidor do Vault está em execução. Se o Vault estiver sendo executado no mesmo cluster e namespace que a Apigee, o formato geralmente será http://vault.APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Aplique o SecretProviderClasses acima ao namespace 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 secret externo para o AX Hash Salt.
1. No arquivo overrides.yaml, adicione a seguinte configuração para ativar o uso de secrets externos para o AX Hash Salt:
```
axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```
2. Aplique a mudança fazendo upgrade do gráfico do Helm org:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Ative o secret externo para a senha do Redis.
1. No arquivo overrides.yaml, adicione a seguinte configuração para ativar o uso de secrets externos para a senha do Redis:
```
redis:
  auth:
    secretProviderClass: apigee-redis-spc
```
2. Em seguida, aplique as mudanças fazendo upgrade dos gráficos operator e redis na seguinte ordem:
```
helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
helm upgrade redis apigee-redis/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
Ativar o secret externo para as chaves de criptografia
1. No arquivo overrides.yaml, adicione a seguinte configuração para ativar o uso de secrets externos para as chaves de criptografia no nível da organização:
```
encryptionKeySecretProviderClass: apigee-orgencryptionkeys-spc
```
2. Faça upgrade do gráfico do Helm org para aplicar a alteração:
```
helm upgrade org apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  -f overrides.yaml
```
3. No arquivo overrides.yaml de cada ambiente, adicione a seguinte configuração para as chaves de criptografia específicas do ambiente:
```
envs:
- name: ENV_NAME
  encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc
```
4. Aplique a alteração fazendo upgrade do gráfico do Helm env 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 arquivo overrides.yaml, remova a configuração que ativou o uso de secrets externos para o AX Hash Salt:
```
# Comment out or delete the following line:
# axHashSaltSecretProviderClass: apigee-axhashsalt-spc
```

Aplique a mudança fazendo upgrade do gráfico do Helm org:

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

Senha do Redis

No arquivo overrides.yaml, remova a configuração que ativou o uso de secrets externos para a senha do Redis:
```
redis:
  auth:
  # Comment out or delete the following line:
  # secretProviderClass: apigee-redis-spc
```

Em seguida, aplique as mudanças fazendo upgrade dos gráficos redis e operator na 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 criptografia

No arquivo overrides.yaml, remova a configuração que ativou o uso de secrets externos para as chaves de criptografia do ambiente:

envs:
  - name: ENV_NAME
  # Comment out or delete the following line:
  # encryptionKeySecretProviderClass: apigee-envencryptionkeys-spc

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

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

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

Em seguida, faça upgrade do gráfico do Helm org:

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