Nota

Questa esercitazione è disponibile in un ambiente di esercitazione pratica gratuito fornito da Oracle.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Quando completi il tuo laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Usa segreti con Oracle Cloud Native Environment

Introduzione

Molte applicazioni dispongono di informazioni, come le password, a cui devono accedere solo gli utenti autorizzati. Questa è la situazione in cui Kubernetes Secrets può aiutare. Offrono un modo per gestire in modo sicuro i dati sensibili come password, SSH e chiavi API. L'utilizzo di segreti consente la separazione dei dati riservati dal codice dell'applicazione, riducendo il rischio che i dati sensibili vengano esposti o modificati durante il flusso di lavoro dei Pod.

Prima di iniziare, è utile conoscere alcuni dettagli di base sui segreti Kubernetes:

Devono essere presenti prima di essere utilizzati da un Pod.
Definito utilizzando una coppia KEY e VALUE.
Limitato a una dimensione massima di 1 MB per impedire loro di utilizzare tutta la memoria kube-apiserver e kubelet.
Definirli come immutabili per proteggerli da modifiche accidentali o indesiderate.

Importante: i segreti Kubernetes non vengono cifrati per impostazione predefinita perché sono solo codificati con Base64 e vengono memorizzati senza cifratura in etcd. Quindi chiunque abbia accesso a etcd può visualizzare o modificare un Segreto. L'utilizzo di Kubernetes Secrets può essere reso sicuro utilizzando uno dei seguenti metodi:

Abilita Cifratura dei dati a riposo per i segreti.

Configurare l'accesso con meno privilegi utilizzando l'autorizzazione RBAC.

Limitare l'accesso ai segreti per contenitori specifici.

Utilizzo di un servizio di gestione dei segreti esterno.

Questa esercitazione descrive le nozioni di base di Kubernetes Secrets e illustra un semplice caso d'uso.

Per ulteriori informazioni su Oracle Cloud Native Environment 2, fai riferimento al sito corrente della documentazione di rilascio.

Obiettivi

In questo tutorial imparerai a:

Crea un segreto
Visualizza un segreto
Decodifica di un segreto
Utilizzare un segreto per definire una variabile di ambiente in una distribuzione

Prerequisiti

Installazione di Oracle Cloud Native Environment (Oracle CNE)
Un singolo nodo di controllo e un nodo di lavoro

Configura Oracle Cloud Native Environment

Nota: se è in esecuzione nella propria tenancy, leggere il progetto linux-virt-labs GitHub README.md e completare i prerequisiti prima di distribuire l'ambiente di laboratorio.

Aprire un terminale sul Luna Desktop.

Duplicare il progetto linux-virt-labs GitHub.

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

Passare alla directory di lavoro.
```
cd linux-virt-labs/ocne2
```

Installare le raccolte richieste.

ansible-galaxy collection install -r requirements.yml

Implementare l'ambiente di laboratorio.
```
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'"
```
L'ambiente di esercitazione pratica gratuito richiede l'aggiunta della variabile local_python_interpreter, che imposta ansible_python_interpreter per le riproduzioni eseguite su localhost. Questa variabile è necessaria perché l'ambiente installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python, situato sotto i moduli python3.6.

La forma di distribuzione predefinita utilizza la CPU AMD e Oracle Linux 8. Per utilizzare una CPU Intel o Oracle Linux 9, aggiungere -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando di distribuzione.

Importante: attendere che il playbook venga eseguito correttamente e raggiungere il task di sospensione. In questa fase del playbook, l'installazione di Oracle CNE è completa e le istanze sono pronte. Prendi nota del gioco precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce e qualsiasi altra informazione di distribuzione necessaria durante l'esecuzione del laboratorio.

Accedi al cluster Kubernetes

Aprire un terminale e connettersi tramite SSH all'istanza ocne.
```
ssh oracle@<ip_address_of_instance>
```
Attendere che il cluster venga stabilizzato e che tutti i pod vengano segnalati in stato di esecuzione.
```
watch kubectl get pods -A
```
Dopo che tutti i pod mostrano uno STATUS di In esecuzione, digitare ctrl-c per uscire dal comando watch.
Confermare il numero di nodi presenti.
```
kubectl get nodes
```

Creazione dei segreti

Esistono tre modi per creare segreti Kubernetes, tra cui:

Utilizzare lo strumento della riga di comando kubectl per gestire i segreti direttamente dalla riga di comando.
Utilizzo dello strumento della riga di comando kubectl con un file di configurazione delle risorse.
Utilizzo dello strumento Personalizza gestione oggetti con un file kustomization.yaml.

Utilizzo di Kubectl direttamente dalla riga di comando

Kubectl crea segreti in due modi:

Passarli direttamente tramite la riga di comando.
Memorizzarli come credenziali nei file.

Creare un segreto utilizzando valori letterali passati direttamente dalla riga di comando.

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

Nota: utilizzare le virgolette singole '' per eseguire l'escape di caratteri speciali quali $, \, $, &, = e ! inclusi nei valori stringa. Altrimenti, la shell di comando li interpreterà.

Output di esempio:

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

Utilizzo di Kubectl con i file delle credenziali memorizzati

Il contenuto del file diventa VALUE e il nome del file diventa KEY.

Creare i file delle credenziali.

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

Creare un segreto utilizzando i file salvati.
```
kubectl create secret generic my-file-secret \
 --from-file=username=./username.txt \
 --from-file=password=./password.txt
```
Nota: il funzionamento predefinito utilizza il nome file come valore KEY per mostrare come eseguire l'override del comportamento predefinito e dichiarare il valore del nome KEY direttamente dalla riga di comando utilizzando il metodo --from-file=[key]=[path to file].
Informazioni aggiuntive:

In alternativa, è possibile creare un segreto da più file memorizzati in una sottodirectory.
1. Crea una sottocartella.
  mkdir secrets
2. Creare i file delle credenziali.
  echo -n 'user1' > ./secrets/username.txt echo -n 'my-super-secret-password' > ./secrets/password.txt
3. Creare un segreto utilizzando i file delle credenziali in una sottodirectory.
  kubectl create secret generic my-secret --from-file=./secrets/
  Nota: questo metodo utilizza ogni nome file come valore KEY e il contenuto del file come VALUE.

Utilizzo di Kubectl per applicare un file di configurazione YAML

Creare il file di definizione YAML dei segreti.

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

Nota: i valori del segreto nel file YAML devono essere codificati con BASE64.

Applicare il segreto.
```
kubectl apply -f db-credentials.yaml
```

Utilizzo di Kustomize con un file `kustomization.yaml`

La creazione di segreti con personalizza richiede un file kustomization.yaml. Tale file deve definire un valore secretGenerator utilizzando uno dei metodi seguenti:

I file che memorizzano i valori dati segreti e i nomi file diventano i valori KEY.
La versione letterale non cifrata del valore data in un file.
File delle variabili di ambiente (.env).

Quanto sopra non richiede che i valori segreti siano codificati con Base64 quando si utilizza Kustomize. Il nome del file YAML utilizzato da Kustomize deve essere kustomization.yaml o kustomization.yml.

In questo esempio viene illustrato come utilizzare i valori letterali per creare un segreto.

Creare il file secretGenerator.

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

Genera il segreto con Kustomize.

kubectl -n default apply -k .

Output di esempio:

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

Gestione dei segreti Kubernetes

Puoi memorizzare i segreti Kubernetes in spazi di nomi diversi. Pertanto, è necessario utilizzare l'opzione -n per recuperare i segreti da uno spazio di nomi specifico oppure utilizzare --all-namespaces o -A per recuperare i segreti da tutti gli spazi di nomi. Se non si specifica uno spazio di nomi, il comando kubectl utilizza lo spazio di nomi default. Lo stesso comportamento si applica quando si crea un segreto Kubernetes.

Elenca i segreti Kubernetes esistenti

Elenca i segreti appena creati.

kubectl get secrets

Output di esempio:

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

Ottenere ulteriori dettagli sui segreti appena creati.

kubectl describe secrets

Output di esempio:

[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

Si noti che i comandi kubectl get e kubectl describe non visualizzano il contenuto di un secret per evitare l'esposizione accidentale o l'inclusione in un file di log.

Visualizzare le informazioni per uno dei segreti.

kubectl -n default describe secret db-credentials

Output di esempio:

[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

Decodifica un segreto Kubernetes

Visualizzare i dati memorizzati per uno dei segreti.

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

Output di esempio:

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

L'output visualizza le coppie chiave:valore codificate per i dati del segreto. I dati dei valori sono codificati con base64.

Decodificare i dati Key:Value codificati.
```
echo <BASE64-VALUE-FOR-PASSWORD> | base64 --decode
```
Output di esempio:
```
[oracle@ocne ~]$ echo bXktc3VwZXItc2VjcmV0LXBhc3Nvd3Jk | base64 --decode
my-password[oracle@ocne ~]$ 
```
AVVERTENZA: questi passi possono generare un record dei dati segreti presenti nella cronologia della shell. Evitare questo combinando entrambi i passaggi, come mostrato nel passo successivo.

Un metodo più sicuro per decodificare i dati Key:Value codificati.

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

Output di esempio:

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

Modifica un segreto

Come molti oggetti Kubernetes, puoi modificare un segreto Kubernetes. L'unica eccezione è rappresentata dal fatto che un segreto viene dichiarato immutabile.

Modifica un segreto.

kubectl edit secrets my-literal-secret

Viene aperto l'editor predefinito (vi per impostazione predefinita) per consentire l'aggiornamento dei valori dei segreti codificati Base64 nel campo data:.

Output di esempio:

# 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

Uscire dall'editor senza salvare premendo il tasto Esc, seguito dai tasti :q!.
Output di esempio:
```
[oracle@ocne ~]$ kubectl edit secrets my-literal-secret
Edit cancelled, no changes made.
```

Elimina un segreto

È possibile rimuovere un segreto utilizzando il comando kubectl -n <NAMESPACE> delete.

Elimina i segreti.

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

Output di esempio:

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

Nota: è possibile eliminare più segreti delimitandoli con spazi.

Usa segreti con una distribuzione

Successivamente, creerai una distribuzione utilizzando i dati del segreto Kubernetes creati.

Elenca tutti i segreti nello spazio di nomi predefinito.

kubectl get secrets -n default

Output di esempio:

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

Creare un file YAML di distribuzione.

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

Crea la distribuzione

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

Confermare che si distribuisce.

kubectl get deployments

Potrebbe essere necessario ripetere la query alcune volte mentre si distribuisce.

Output di esempio:

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

Recupera il nome del pod distribuito.

kubectl get pods

Output di esempio:

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

Nota: il nome del pod sarà diverso.

Verificare che il pod distribuito abbia utilizzato il segreto.

kubectl -n default describe pod <POD-NAME>

dove:

<POD-NAME>: il nome del pod nella distribuzione.

Output di esempio:

[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 ~]$ 

Nota: controllare la sezione Environment: per confermare la presenza delle variabili $USER e $PASSWORD.

Verificare che le variabili di ambiente siano presenti nel pod distribuito.
```
kubectl exec -it <POD-NAME> -- printenv USER PASSWORD
```
dove:
- <POD-NAME>: il nome del pod nella distribuzione.
Output di esempio:
```
[oracle@ocne ~]$ kubectl exec -it echo-deployment-59bff74847-9nnkq -- printenv USER PASSWORD
my-user
my-password
```
L'output conferma che è stato utilizzato correttamente Kubernetes Secrets come variabile di ambiente nel pod distribuito.

Passi successivi

Questa esercitazione ha dimostrato come creare e utilizzare i segreti Kubernetes per limitare l'accesso non autorizzato alle informazioni riservate. Tuttavia, questo è solo l'inizio. Controlla la stazione di formazione Oracle Linux per ulteriori esercitazioni e contenuti.

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

Use Secrets with Oracle Cloud Native Environment

G39903-01

Usa segreti con Oracle Cloud Native Environment

Introduzione

Obiettivi

Prerequisiti

Configura Oracle Cloud Native Environment

Accedi al cluster Kubernetes

Creazione dei segreti

Utilizzo di Kubectl direttamente dalla riga di comando

Utilizzo di Kubectl con i file delle credenziali memorizzati

Utilizzo di Kubectl per applicare un file di configurazione YAML

Utilizzo di Kustomize con un file kustomization.yaml

Gestione dei segreti Kubernetes

Elenca i segreti Kubernetes esistenti

Decodifica un segreto Kubernetes

Modifica un segreto

Elimina un segreto

Usa segreti con una distribuzione

Passi successivi

Collegamenti correlati

Altre risorse di apprendimento

Utilizzo di Kustomize con un file `kustomization.yaml`