Contribuisci a migliorare questa pagina

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Per contribuire a questa guida per l'utente, scegli il GitHub link Modifica questa pagina nel riquadro destro di ogni pagina.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo di una policy di gruppo di sicurezza per un pod Amazon EKS

Per utilizzare i gruppi di sicurezza per i pod, è necessario disporre di un gruppo di sicurezza esistente. I passaggi seguenti mostrano l’utilizzo delle policy di gruppo di sicurezza per un pod. Se non diversamente indicato, completa tutti i passaggi nello stesso terminale, poiché nei passaggi successivi sono utilizzate variabili che non persistono tra i terminali.

Se disponi di un Pod con EC2 istanze Amazon, devi configurare il plug-in prima di utilizzare questa procedura. Per ulteriori informazioni, consulta Configurazione del plugin CNI di Amazon VPC per Kubernetes per gruppi di sicurezza per i pod Amazon EKS.

Crea un namespace Kubernetes in cui distribuire le risorse . Puoi sostituirlo my-namespace con il nome di uno spazio dei nomi che desideri utilizzare.
```
kubectl create namespace my-namespace
```
Implementa una SecurityGroupPolicy Amazon EKS nel cluster.
1. Copia i seguenti contenuti sul dispositivo. Puoi sostituirlo podSelector con serviceAccountSelector se preferisci selezionare i Pod in base alle etichette degli account di servizio. É necessario specificare uno selettore. Un podSelector vuoto (ad esempio: podSelector: {}) seleziona tutti i pod nel namespace. Puoi my-role cambiare il nome del tuo ruolo. Un serviceAccountSelector vuoto seleziona tutti gli account di servizio nel namespace. Puoi sostituirlo my-security-group-policy con un nome per te SecurityGroupPolicy e my-namespace con lo spazio dei nomi in cui desideri crearlo. SecurityGroupPolicy
  
  È necessario sostituirlo my_pod_security_group_id con l'ID di un gruppo di sicurezza esistente. Se non disponi ancora di un gruppo di sicurezza dovrai crearne uno. Per ulteriori informazioni, consulta i gruppi EC2 di sicurezza Amazon per le istanze Linux nella Amazon EC2 User Guide. Puoi specificare da 1 a 5 gruppi di sicurezza. IDs Se si specificano più ID, la combinazione di tutte le regole in tutti i gruppi di sicurezza sarà valida per i pod selezionati.
```
cat >my-security-group-policy.yaml <<EOF
apiVersion: vpcresources.k8s.aws/v1beta1
kind: SecurityGroupPolicy
metadata:
  name: my-security-group-policy
  namespace: my-namespace
spec:
  podSelector:
    matchLabels:
      role: my-role
  securityGroups:
    groupIds:
      - my_pod_security_group_id
EOF
```
  Importante
  Il gruppo di sicurezza o i gruppi specificati per i pod devono soddisfare i criteri seguenti:
  
  Devono essere esistenti. Se non lo sono, quando si distribuisce un pod che corrisponde al selettore, il pod rimane bloccato nel processo di creazione. Se si descrive il pod, si otterrà un messaggio di errore simile al seguente: An error occurred (InvalidSecurityGroupID.NotFound) when calling the CreateNetworkInterface operation: The securityGroup ID 'sg-05b1d815d1EXAMPLE' does not exist.
  
  Devono consentire la comunicazione in ingresso dal gruppo di sicurezza applicato ai nodi (per kubelet) su tutte le porte per cui sono state configurate le sonde.
  
  Devono consentire la comunicazione in uscita tramite le porte 53 TCP e UDP a un gruppo di sicurezza assegnato ai pod (o ai nodi su cui sono eseguiti i pod) che eseguono CoreDNS. Il gruppo di sicurezza per i pod CoreDNS deve consentire il traffico in ingresso tramite le porte 53 TCP e UDP dal gruppo di sicurezza specificato.
  
  Devono disporre delle regole in entrata e in uscita necessarie per comunicare con altri pod.
  
  Devono disporre di regole che consentano ai pod di comunicare con il piano di controllo Kubernetes se si utilizza il gruppo di sicurezza con Fargate. Il modo più semplice per eseguire questa operazione consiste nello specificare il gruppo di sicurezza del cluster come uno dei gruppi di sicurezza.
  
  Le policy dei gruppi di sicurezza si applicano solo ai nuovi pod pianificati. Non incidono sui pod in esecuzione.
2. Implementare la policy.
```
kubectl apply -f my-security-group-policy.yaml
```

Implementa un'applicazione di esempio con un'etichetta che corrisponda al valore my-role per podSelector specificato nel passaggio precedente.

Copia i seguenti contenuti sul dispositivo. Sostituisci i valori di esempio con i tuoi, quindi esegui il comando modificato. Se lo sostituiscimy-role, assicurati che sia uguale al valore specificato per il selettore in un passaggio precedente.


cat >sample-application.yaml <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  namespace: my-namespace
  labels:
    app: my-app
spec:
  replicas: 4
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
        role: my-role
    spec:
      terminationGracePeriodSeconds: 120
      containers:
      - name: nginx
        image: public.ecr.aws/nginx/nginx:1.23
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-app
  namespace: my-namespace
  labels:
    app: my-app
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
EOF

Implementare l'applicazione con il seguente comando. Quando si implementa l’applicazione, il plugin CNI di Amazon VPC per Kubernetes corrisponde all’etichetta role e i gruppi di sicurezza specificati nel passaggio precedente sono applicati al pod.
```
kubectl apply -f sample-application.yaml
```

Visualizza i pod implementati con l’applicazione esemplificativa. Nella parte restante di questo argomento, questo terminale è indicato come TerminalA.
```
kubectl get pods -n my-namespace -o wide
```
Di seguito viene riportato un output di esempio.
```
NAME                             READY   STATUS    RESTARTS   AGE     IP               NODE                                            NOMINATED NODE   READINESS GATES
my-deployment-5df6f7687b-4fbjm   1/1     Running   0          7m51s   192.168.53.48    ip-192-168-33-28.region-code.compute.internal   <none>           <none>
my-deployment-5df6f7687b-j9fl4   1/1     Running   0          7m51s   192.168.70.145   ip-192-168-92-33.region-code.compute.internal   <none>           <none>
my-deployment-5df6f7687b-rjxcz   1/1     Running   0          7m51s   192.168.73.207   ip-192-168-92-33.region-code.compute.internal   <none>           <none>
my-deployment-5df6f7687b-zmb42   1/1     Running   0          7m51s   192.168.63.27    ip-192-168-33-28.region-code.compute.internal   <none>           <none>
```
Nota
Prova questi suggerimenti se qualche pod è bloccato.
- Se qualche pod è bloccato nello stato Waiting, esegui kubectl describe pod my-deployment-xxxxxxxxxx-xxxxx -n my-namespace. Se visualizzi Insufficient permissions: Unable to create Elastic Network Interface., verifica di avere aggiunto la policy IAM al ruolo cluster IAM in un passaggio precedente.
- Se qualche pod è bloccato nello stato Pending, verifica che il tipo di istanza del nodo sia elencato in limits.go e che non sia già stato raggiunto il prodotto del numero massimo di interfacce di rete di filiali supportate dal tipo di istanza moltiplicato per il numero di nodi nel gruppo di nodi. Ad esempio, una istanza m5.large supporta nove interfacce di rete di filiali. Se il gruppo di nodi dispone di cinque nodi, è possibile creare un massimo di 45 interfacce di rete di filiali per il gruppo di nodi. Il 46° pod che si tenta di implementare si troverà in uno stato di Pending finché non viene eliminato un altro pod a cui sono associati gruppi di sicurezza.
Se si esegue kubectl describe pod my-deployment-xxxxxxxxxx-xxxxx -n my-namespace e si visualizza un messaggio simile al seguente, può essere ignorato in modo sicuro. Questo messaggio potrebbe essere visualizzato quando il plugin CNI di Amazon VPC per Kubernetes tenta di impostare la rete host e fallisce durante la creazione dell’interfaccia di rete. Il plug-in registra questo evento fino a quando non viene creata l'interfaccia di rete.
```
Failed to create Pod sandbox: rpc error: code = Unknown desc = failed to set up sandbox container "e24268322e55c8185721f52df6493684f6c2c3bf4fd59c9c121fd4cdc894579f" network for Pod "my-deployment-5df6f7687b-4fbjm": networkPlugin
cni failed to set up Pod "my-deployment-5df6f7687b-4fbjm-c89wx_my-namespace" network: add cmd: failed to assign an IP address to container
```
Non è possibile superare il numero massimo di pod eseguibili sul tipo di istanza. Per un elenco del numero massimo di Pod che puoi eseguire su ogni tipo di istanza, consulta eni-max-pods.txt on. GitHub Quando si elimina un pod a cui sono associati gruppi di sicurezza o si elimina il nodo su cui è in esecuzione il pod, il controller di risorse VPC elimina l’interfaccia di rete di filiali. Se elimini un cluster con pod che utilizzano pod per gruppi di sicurezza, il controller non elimina le interfacce di rete delle diramazioni, per cui dovrai eliminarle personalmente. Per informazioni su come eliminare le interfacce di rete, consulta Delete a network interface nella Amazon EC2 User Guide.
In un terminale separato, accedi alla shell di uno dei pod. Nella parte restante di questo argomento, questo terminale è indicato come TerminalB. Sostituiscilo 5df6f7687b-4fbjm con l'ID di uno dei Pod restituiti nell'output del passaggio precedente.
```
kubectl exec -it -n my-namespace my-deployment-5df6f7687b-4fbjm -- /bin/bash
```
Confermare il funzionamento dell'applicazione di esempio dalla shell in TerminalB.
```
curl my-app
```
Di seguito viene riportato un output di esempio.
```
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
[...]
```
L’output è stato ricevuto in quanto tutti i pod che eseguono l’applicazione sono associati al gruppo di sicurezza creato. Tale gruppo contiene una regola che abilita il traffico tra tutti i pod a cui è associato il gruppo di sicurezza. Il traffico DNS è consentito in uscita da tale gruppo di sicurezza al gruppo di sicurezza del cluster associato ai nodi. I nodi eseguono i pod CoreDNS, su cui i pod hanno eseguito la ricerca del nome.
Da TerminalA, rimuovere le regole del gruppo di sicurezza che consentono la comunicazione DNS dal gruppo di sicurezza al gruppo di sicurezza del cluster. Se non hai aggiunto le regole DNS al gruppo di sicurezza del cluster in un passaggio precedente, sostituiscile $my_cluster_security_group_id con l'ID del gruppo di sicurezza in cui hai creato le regole.
```
aws ec2 revoke-security-group-ingress --group-id $my_cluster_security_group_id --security-group-rule-ids $my_tcp_rule_id
aws ec2 revoke-security-group-ingress --group-id $my_cluster_security_group_id --security-group-rule-ids $my_udp_rule_id
```
Tentare di accedere nuovamente all'applicazione da TerminalB.
```
curl my-app
```
Di seguito viene riportato un output di esempio.
```
curl: (6) Could not resolve host: my-app
```
Il tentativo ha esito negativo perché il pod non è più in grado di accedere ai pod CoreDNS a cui è associato il gruppo di sicurezza del cluster. Il gruppo di sicurezza del cluster non dispone più delle relative regole che consentono la comunicazione DNS dal gruppo di sicurezza associato al pod.

Se si tenta di accedere all’applicazione utilizzando gli indirizzi IP restituiti in un passaggio precedente per uno dei pod, si riceve comunque una risposta perché tutte le porte sono consentite tra i pod a cui è associato il gruppo di sicurezza e non è necessaria una ricerca del nome.

Dopo avere eseguito diverse prove, è possibile rimuovere la policy del gruppo di sicurezza, l’applicazione e il gruppo di sicurezza di esempio creati. Esegui i comandi seguenti da TerminalA.


kubectl delete namespace my-namespace
aws ec2 revoke-security-group-ingress --group-id $my_pod_security_group_id --security-group-rule-ids $my_inbound_self_rule_id
wait
sleep 45s
aws ec2 delete-security-group --group-id $my_pod_security_group_id

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Configura

Interfacce multiple

Utilizzo di una policy di gruppo di sicurezza per un pod Amazon EKS

Importante

Nota