Configurazione di un criterio di rete

Questa pagina mostra come utilizzare i criteri di rete del cluster per controllare se un pod può ricevere traffico di rete in entrata (o in entrata) e se può inviare traffico in uscita (o in uscita).

I criteri di rete consentono di limitare le connessioni tra gli oggetti pod, in modo da ridurre l'esposizione agli attacchi.

I criteri di rete fungono da firewall nel livello 3 o 4 del modello OSI. Non offrono funzionalità aggiuntive, come autorizzazione o crittografia.

Limitazione del traffico in entrata agli oggetti pod

Un oggetto NetworkPolicy consente di configurare i criteri di accesso alla rete per un pod. Gli oggetti NetworkPolicy contengono le seguenti informazioni:

Oggetti pod a cui si applica il criterio. Puoi definire gli oggetti e i carichi di lavoro dei pod con etichette e selettori.
Tipo di traffico interessato dal criterio di rete: Ingress per il traffico in entrata, In uscita per il traffico in uscita o entrambi.
Per i criteri Ingress, quali oggetti pod possono connettersi agli oggetti pod specificati.
Per i criteri in uscita, gli oggetti Pod a cui possono essere collegati gli oggetti pod specificati.

Esempio di limitazione del traffico in entrata

Questa sezione mostra la creazione di una limitazione del traffico in entrata su un'applicazione di esempio. Modifica questo esempio in base al tuo ambiente applicativo.

Esegui un'applicazione server web con l'etichetta app=hello ed esponila internamente nel cluster:

kubectl run hello-web --labels app=hello \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 \
    --port 8080 --expose

Configura un NetworkPolicy per consentire il traffico al pod hello-web solo dagli oggetti app=foo Pod. I cluster Anthos su AWS bloccano il traffico in entrata dagli oggetti pod che non hanno questa etichetta, nonché il traffico esterno e il traffico dagli oggetti pod in uno spazio dei nomi diverso.

Il manifest seguente seleziona gli oggetti Pod con l'etichetta app=hello e specifica un criterio Ingress per consentire il traffico solo dagli oggetti Pod con l'etichetta app=foo:

network-policies/hello-allow-from-foo.yaml

Visualizza su GitHub


# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: hello-allow-from-foo
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: hello
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: foo
---

Applica questo criterio al cluster:

kubectl apply -f hello-allow-from-foo.yaml

Verifica il criterio Ingress

Esegui un pod temporaneo con l'etichetta app=foo. Per verificare che il traffico in entrata sia consentito, invia una richiesta all'endpoint hello-web:8080:
```
kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080
```
Se il traffico dal pod app=foo agli oggetti pod app=hello è abilitato, l'output ha il seguente aspetto:
```
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
```
Esegui un pod temporaneo con un'etichetta diversa (app=other) ed effettua la stessa richiesta per osservare che il traffico non è consentito:
```
kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080
```
L'output conferma che la connessione non riceve una risposta:
```
wget: download timed out
```

Limita il traffico in uscita dagli oggetti pod

Puoi limitare il traffico in uscita proprio come faresti per il traffico in entrata.

Tuttavia, per eseguire query su nomi host interni come hello-web o nomi host esterni come www.example.com, devi creare un criterio in uscita che consenta il traffico DNS sulla porta 53 utilizzando i protocolli TCP e UDP.

Per abilitare i criteri di rete in uscita, esegui il deployment di un NetworkPolicy che controlla il traffico in uscita dagli oggetti pod con l'etichetta app=foo e consenti il traffico solo agli oggetti pod con l'etichetta app=hello, nonché il traffico DNS.

Il file manifest seguente specifica un elemento NetworkPolicy che controlla il traffico in uscita dagli oggetti pod con l'etichetta app=foo con due destinazioni consentite:

Oggetti pod nello stesso spazio dei nomi con l'etichetta app=hello
Endpoint interni o esterni sulla porta 53 (UDP e TCP)

network-policies/foo-allow-to-hello.yaml

Visualizza su GitHub


# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: foo-allow-to-hello
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: foo
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: hello
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP
---

Applica questo criterio al cluster:

kubectl apply -f foo-allow-to-hello.yaml

Convalida il criterio in uscita

Esegui il deployment di una nuova applicazione web chiamata hello-web-2 ed esponila internamente nel cluster:

kubectl run hello-web-2 --labels app=hello-2 \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

Esegui un pod temporaneo con l'etichetta app=foo e convalida che può stabilire connessioni a hello-web:8080:

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

Il pod risponde alla richiesta:

Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

Verifica che il pod non sia in grado di stabilire connessioni a hello-web-2:8080:

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

L'output conferma che la connessione non riceve una risposta:

wget: download timed out

Verifica che il pod non sia in grado di stabilire connessioni a siti web esterni come www.example.com.
```
kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com
```
L'output conferma che la connessione non riceve una risposta:
```
wget: download timed out
```

Esegui la pulizia

Per rimuovere le risorse che hai creato in questo tutorial, esegui questi comandi:

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

Passaggi successivi

Documentazione sui criteri di rete di Kubernetes
Utilizza il logging dei criteri di rete per registrare quando le connessioni agli oggetti Pod sono consentite o negate dai criteri di rete del cluster.