Observação:

Este tutorial está disponível em um ambiente de laboratório gratuito fornecido pela Oracle.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Use Segredos com o Oracle Cloud Native Environment

Introdução

Muitos aplicativos possuem informações, como senhas, que somente usuários autorizados devem acessar. Essa situação é onde os Segredos do Kubernetes podem ajudar. Eles fornecem uma maneira de gerenciar com segurança dados confidenciais, como senhas, SSH e chaves de API. O uso de segredos permite a separação de dados confidenciais do código do aplicativo, o que reduz o risco de exposição ou modificação de dados confidenciais durante o fluxo de trabalho dos seus Pods.

Antes de começar, ele ajuda a saber alguns detalhes básicos sobre Segredos do Kubernetes:

Eles devem estar presentes antes de serem usados por um Pod.
Definido usando um par CHAVE e VALOR.
Limitado a um tamanho máximo de 1MB para impedi-los de usar toda a memória kube-apiserver e kubelet.
Defina-as como imutáveis para protegê-las contra modificações acidentais ou indesejadas.

Importante: Por padrão, os Segredos do Kubernetes não são criptografados porque só são codificados em Base64 e armazenados sem criptografia no etcd. Assim, qualquer pessoa com acesso ao etcd pode ver ou alterar um Segredo. O uso de Segredos do Kubernetes pode ser seguro usando qualquer um destes métodos:

Ative a Criptografia em Repouso para Segredos.

Configurar o acesso de menor privilégio usando a autorização RBAC.

Restringir o acesso a segredos para contêineres específicos.

Usando um serviço de gerenciamento de segredos externo.

Este tutorial aborda os conceitos básicos de Segredos do Kubernetes e demonstra um caso de uso simples.

Para obter mais informações sobre o Oracle Cloud Native Environment 2, consulte o site atual da Documentação de Versão.

Objetivos

Neste tutorial, você aprenderá a:

Criar um Segredo
Exibir um Segredo
Decodificar um Segredo
Usar um Segredo para definir uma variável de ambiente em uma implantação

Pré-requisitos

Instalação do Oracle Cloud Native Environment (Oracle CNE)
Um único nó de controle e um nó de trabalho

Configurar o Oracle Cloud Native Environment

Observação: Se estiver em execução na sua própria tenancy, leia o projeto linux-virt-labs GitHub README.md e conclua os pré-requisitos antes de implantar o ambiente de laboratório.

Abra um terminal no Luna Desktop.

Clone o projeto linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Altere para o diretório de trabalho.
```
cd linux-virt-labs/ocne2
```

Instale as coleções necessárias.

ansible-galaxy collection install -r requirements.yml

Implante o ambiente de laboratório.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e install_ocne_rpm=true -e create_ocne_cluster=true -e "ocne_cluster_node_options='-n 1 -w 1'"
```
O ambiente de laboratório gratuito requer a variável extra local_python_interpreter, que define ansible_python_interpreter para reproduções em execução no localhost. Essa variável é necessária porque o ambiente instala o pacote RPM do Oracle Cloud Infrastructure SDK para Python, localizado nos módulos python3.6.

A forma de implantação padrão usa a CPU AMD e o Oracle Linux 8. Para usar uma CPU Intel ou um Oracle Linux 9, adicione -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" ao comando de implantação.

Importante: Aguarde a execução bem-sucedida do playbook e atinja a tarefa de pausa. Neste estágio do playbook, a instalação do Oracle CNE está concluída e as instâncias estão prontas. Anote o jogo anterior, que imprime os endereços IP públicos e privados dos nós que ele implanta e quaisquer outras informações de implantação necessárias durante a execução do laboratório.

Acessar o Cluster do Kubernetes

Abra um terminal e conecte-se via SSH à instância do ocne.
```
ssh oracle@<ip_address_of_instance>
```
Aguarde a estabilização do cluster e todos os pods reportem em um estado de execução.
```
watch kubectl get pods -A
```
Depois que todos os pods mostrarem um STATUS de Em Execução, digite ctrl-c para sair do comando watch.
Confirme quantos nós estão presentes.
```
kubectl get nodes
```

Criando Segredos

Há três maneiras de criar Segredos do Kubernetes, que são:

Usar a ferramenta de linha de comando kubectl para gerenciar segredos diretamente da linha de comando.
Usando a ferramenta de linha de comando kubectl com um arquivo de configuração de recurso.
Usando a ferramenta de gerenciamento de objetos de personalização com um arquivo kustomization.yaml.

Usando o Kubectl Diretamente da Linha de Comando

Kubectl cria segredos de uma de duas maneiras:

Passando-os diretamente através da linha de comando.
Armazenando-os como credenciais em arquivos.

Crie um segredo usando valores literais passados diretamente da linha de comando.

kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password

Observação: use aspas simples '' para fazer escape de caracteres especiais, como $, \, $, &, = e !, incluídos nos valores de string. Caso contrário, o shell de comando os interpretará.

Exemplo de Saída:

[oracle@ocne ~]$ kubectl create secret generic my-literal-secret --from-literal=username=my-user --from-literal=password=my-password
secret/my-literal-secret created

Usando o Kubectl com Arquivos de Credenciais Armazenados

O conteúdo do arquivo se torna o VALUE, e o nome do arquivo se torna a KEY.

Crie os arquivos de credenciais.

echo -n 'admin' > ./username.txt
echo -n 'S!B\*d$zDsb=' > ./password.txt

Crie um Segredo usando arquivos salvos.
```
kubectl create secret generic my-file-secret \
 --from-file=username=./username.txt \
 --from-file=password=./password.txt
```
Observação: O comportamento default usa o nome do arquivo como o valor KEY para mostrar como substituir o comportamento default e declarar o nome-valor KEY diretamente da linha de comando usando o método --from-file=[key]=[path to file].
Informação Extra:

Como alternativa, você pode criar um segredo com base em vários arquivos armazenados em um subdiretório.
1. Criar um subdiretório.
  mkdir secrets
2. Crie os arquivos de credenciais.
  echo -n 'user1' > ./secrets/username.txt echo -n 'my-super-secret-password' > ./secrets/password.txt
3. Crie um Segredo usando arquivos de credenciais em um subdiretório.
  kubectl create secret generic my-secret --from-file=./secrets/
  Observação: esse método usa cada nome de arquivo como o valor KEY e o conteúdo do arquivo como o VALUE.

Usando o Kubectl para Aplicar um Arquivo de Configuração YAML

Criar o arquivo de definição YAML de Segredos.

cat << EOF | tee db-credentials.yaml > /dev/null
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
  # immutable: true
type: Opaque
data:
  username: "bXktdXNlcg=="
  password: "bXktcGFzc3dvcmQ="
EOF

Observação: Os valores de Segredo no arquivo YAML devem ser codificados em BASE64.

Aplique o segredo.
```
kubectl apply -f db-credentials.yaml
```

Usando o Kustomize com um Arquivo `kustomization.yaml`

A criação de Segredos com Personalizar requer um arquivo kustomization.yaml. Esse arquivo deve definir uma secretGenerator usando um dos seguintes métodos:

Os arquivos que armazenam os valores de dados secretos e os nomes de arquivo se tornam os valores de CHAVE.
A versão literal não criptografada do valor data em um arquivo.
Arquivos de variável de ambiente (.env).

Todas as opções acima não exigem que os valores de segredo sejam codificados em Base64 ao usar o Kustomize. O nome do arquivo YAML usado pelo Kustomize deve ser kustomization.yaml ou kustomization.yml.

Este exemplo mostra como usar Literais para criar um Segredo.

Crie o arquivo secretGenerator.

cat << EOF | tee kustomization.yaml > /dev/null
secretGenerator:
- name: database-credentials
  literals:
  - username=admin
  - password=password
EOF

Gere o segredo com Kustomize.

kubectl -n default apply -k .

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default apply -k .
secret/database-credentials-fd8288cb7g created

Gerenciando Segredos do Kubernetes

Você pode armazenar Segredos do Kubernetes em diferentes namespaces. Portanto, você precisa usar a opção -n para recuperar Segredos de um namespace específico ou usar --all-namespaces ou -A para recuperar Segredos de todos os namespaces. O comando kubectl usará o namespace default se você não especificar um namespace. O mesmo comportamento se aplica ao criar um Segredo do Kubernetes.

Listar Segredos Existentes do Kubernetes

Liste os Segredos recém-criados.

kubectl get secrets

Exemplo de Saída:

NAME                              TYPE     DATA   AGE
database-credentials-fd8288cb7g   Opaque   2      34s
db-credentials                    Opaque   2      2m16s
my-file-secret                    Opaque   2      2m40s
my-literal-secret                 Opaque   2      2m51s

Obtenha mais detalhes sobre os Segredos recém-criados.

kubectl describe secrets

Exemplo de Saída:

[oracle@ocne ~]$ kubectl describe secrets
Name:         database-credentials-fd8288cb7g
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
password:  8 bytes
username:  5 bytes


Name:         db-credentials
Namespace:    default
...
...

Name:         my-literal-secret
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
username:  7 bytes
password:  11 bytes

Observe que os comandos kubectl get e kubectl describe não exibem o conteúdo de um secret para impedir a exposição acidental ou a inclusão em um arquivo de log.

Exiba informações de um dos Segredos.

kubectl -n default describe secret db-credentials

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default describe secret db-credentials
Name:         db-credentials
Namespace:    default
Labels:       <none>
Annotations:  <none>

Type:  Opaque

Data
====
password:  11 bytes
username:  7 bytes

Decodificar um Segredo do Kubernetes

Exiba os dados armazenados de um dos Segredos.

kubectl -n default get secret db-credentials -o jsonpath='{.data}'

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default get secret db-credentials -o jsonpath='{.data}'
{"password":"bXktcGFzc3dvcmQ=","username":"bXktdXNlcg=="}[oracle@ocne ~]$ 

A saída exibe os pares Chave:Valor codificados para os dados secretos. Os dados do valor são codificados em base64.

Decodifique os dados de Chave:Valor codificados.
```
echo <BASE64-VALUE-FOR-PASSWORD> | base64 --decode
```
Exemplo de Saída:
```
[oracle@ocne ~]$ echo bXktc3VwZXItc2VjcmV0LXBhc3Nvd3Jk | base64 --decode
my-password[oracle@ocne ~]$ 
```
ADVERTÊNCIA: Essas etapas podem resultar em um registro dos dados secretos no histórico do shell. Evite isso combinando ambas as etapas, conforme mostrado na próxima etapa.

Um método mais seguro para decodificar dados Key:Value codificados.

kubectl -n default get secret db-credentials -o jsonpath='{.data.password}' | base64 --decode

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default get secret db-credentials -o jsonpath='{.data.password}' | base64 --decode
my-password[oracle@ocne ~]$ 

Editar um Segredo

Como muitos objetos do Kubernetes, você pode editar um Segredo do Kubernetes. A única exceção é quando um segredo é declarado imutável.

Editar um Segredo.

kubectl edit secrets my-literal-secret

O editor padrão é aberto (vi por padrão) para permitir que você atualize os valores de segredo codificados Base64 no campo data:.

Exemplo de Saída:

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
data:
  password: bXktcGFzc3dvcmQ=
  username: bXktdXNlcg==
kind: Secret
metadata:
  creationTimestamp: "2025-05-09T10:56:14Z"
  name: my-literal-secret
  namespace: default
  resourceVersion: "1689"
  uid: 394dfda3-025a-417d-bbfe-c4851a6b6cff
type: Opaque
~                                                                                                                                       
~                                                                                                                                             
~                                                                                                                                       
~                                                                                                                                             
"/tmp/kubectl-edit-1267071353.yaml" 16L, 480C

Saia do editor sem salvar pressionando a tecla Esc, seguida pelas teclas :q!.
Exemplo de Saída:
```
[oracle@ocne ~]$ kubectl edit secrets my-literal-secret
Edit cancelled, no changes made.
```

Excluir um segredo

Você pode remover um segredo usando o comando kubectl -n <NAMESPACE> delete.

Exclua os Segredos.

kubectl -n default delete secret my-file-secret my-literal-secret

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default delete secret my-file-secret  my-literal-secret
secret "my-file-secret" deleted
secret "my-literal-secret" deleted

Observação: você pode excluir vários segredos delimitando-os por espaço.

Usar Segredos com uma Implantação

Em seguida, você criará uma implantação usando os dados do Segredo do Kubernetes que criou.

Liste todos os Segredos no namespace padrão.

kubectl get secrets -n default

Exemplo de Saída:

[oracle@ocne ~]$ kubectl get secrets -n default
NAME                              TYPE     DATA   AGE
database-credentials-fd8288cb7g   Opaque   2      10m
db-credentials                    Opaque   2      8m

Criar um arquivo YAML de implantação.

cat << EOF | tee echo-deployment.yaml > /dev/null
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: echo
  template:
    metadata:
      labels:
        app: echo
    spec:
      containers:
      - name: echo
        image: ghcr.io/oracle/oraclelinux:9
        command: ["/bin/bash", "-c"]
        args: ["echo 'Username: $USER' 'Password: $PASSWORD'; sleep infinity"]
        env:
        - name: USER
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: username
        - name: PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: password
      restartPolicy: Always
EOF

Criar a implantação

kubectl -n default apply -f echo-deployment.yaml

Confirme se ele é implantado.

kubectl get deployments

Talvez seja necessário consultar novamente algumas vezes enquanto ele é implementado.

Exemplo de Saída:

[oracle@ocne ~]$ kubectl get deployments 
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
echo-deployment   1/1     1            1           4m

Obtenha o nome do Pod implantado.

kubectl get pods

Exemplo de Saída:

[oracle@ocne ~]$ kubectl get pods
NAME                               READY   STATUS    RESTARTS   AGE
echo-deployment-59bff74847-9nnkq   1/1     Running   0          6m

Observação: O nome do seu Pod será diferente.

Verifique se o Pod implantado usou o segredo.

kubectl -n default describe pod <POD-NAME>

Onde:

<POD-NAME> - O nome do Pod na sua implantação.

Exemplo de Saída:

[oracle@ocne ~]$ kubectl -n default describe pod echo-deployment-59bff74847-9nnkq
Name:             echo-deployment-59bff74847-9nnkq
Namespace:        default
Priority:         0
Service Account:  default
Node:             ocne-worker-1/192.168.122.77
Start Time:       Mon, 12 May 2025 13:42:25 +0000
...
...
    Ready:          True
    Restart Count:  0
    Environment:
      USER:      <set to the key 'username' in secret 'db-credentials'>  Optional: false
      PASSWORD:  <set to the key 'password' in secret 'db-credentials'>  Optional: false
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-5fp4d (ro)
Conditions:
  Type                        Status
  PodReadyToStartContainers   True 
  Initialized                 True
...
..
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:                      <none>
[oracle@ocne ~]$ 

Observação: Verifique se a seção Environment: confirma a presença das variáveis $USER e $PASSWORD.

Confirme se as variáveis de ambiente estão presentes no Pod implantado.
```
kubectl exec -it <POD-NAME> -- printenv USER PASSWORD
```
Onde:
- <POD-NAME> - O nome do Pod na sua implantação.
Exemplo de Saída:
```
[oracle@ocne ~]$ kubectl exec -it echo-deployment-59bff74847-9nnkq -- printenv USER PASSWORD
my-user
my-password
```
A saída confirma que você usou com sucesso os Segredos do Kubernetes como uma variável de ambiente no pod implantado.

Próximas etapas

Este tutorial demonstrou como criar e usar Segredos do Kubernetes para restringir o acesso não autorizado a informações confidenciais. No entanto, este é apenas o começo. Confira o Oracle Linux Training Station para obter tutoriais e conteúdo adicionais.

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal do Oracle Learning YouTube. Além disso, acesse education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Use Secrets with Oracle Cloud Native Environment

G39906-01

Use Segredos com o Oracle Cloud Native Environment

Introdução

Objetivos

Pré-requisitos

Configurar o Oracle Cloud Native Environment

Acessar o Cluster do Kubernetes

Criando Segredos

Usando o Kubectl Diretamente da Linha de Comando

Usando o Kubectl com Arquivos de Credenciais Armazenados

Usando o Kubectl para Aplicar um Arquivo de Configuração YAML

Usando o Kustomize com um Arquivo kustomization.yaml

Gerenciando Segredos do Kubernetes

Listar Segredos Existentes do Kubernetes

Decodificar um Segredo do Kubernetes

Editar um Segredo

Excluir um segredo

Usar Segredos com uma Implantação

Próximas etapas

Links Relacionados

Mais Recursos de Aprendizagem

Usando o Kustomize com um Arquivo `kustomization.yaml`