

 **Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Demostración de Stars de política de red para Amazon EKS
<a name="network-policy-stars-demo"></a>

Esta demostración crea un frontend, un backend y un servicio cliente en el clúster de Amazon EKS. La demostración también crea una interfaz gráfica de usuario de administración que muestra las rutas de entrada y salida disponibles entre los servicios. Le recomendamos que complete la demostración en un clúster en el que no ejecute cargas de trabajo de producción.

Cuando aún no se ha creado ninguna política de red, todos los servicios pueden comunicarse en ambas direcciones. Después de aplicar las políticas de red, puede ver que el cliente solo puede comunicarse con el servicio frontend y el backend solo puede aceptar tráfico del frontend.

1. Aplique los servicios de frontend, backend, cliente e interfaz de usuario de administración:

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/namespace.yaml
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/management-ui.yaml
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/backend.yaml
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/frontend.yaml
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/client.yaml
   ```

1. Visualice todos los pods en el clúster.

   ```
   kubectl get pods -A
   ```

   Un ejemplo de salida sería el siguiente.

   En la salida, debería ver pods en los espacios de nombres que se muestran en la siguiente salida. Los valores de *NAMES* y el número de pods de la columna `READY` son diferentes de los de la siguiente salida. No continúe hasta que vea pods con nombres similares y todos tengan `Running` en la columna `STATUS`.

   ```
   NAMESPACE         NAME                                       READY   STATUS    RESTARTS   AGE
   [...]
   client            client-xlffc                               1/1     Running   0          5m19s
   [...]
   management-ui     management-ui-qrb2g                        1/1     Running   0          5m24s
   stars             backend-sz87q                              1/1     Running   0          5m23s
   stars             frontend-cscnf                             1/1     Running   0          5m21s
   [...]
   ```

1. Para conectarse a la interfaz de usuario de administración, conéctese a la `EXTERNAL-IP` del servicio que se ejecuta en el clúster:

   ```
   kubectl get service/management-ui -n management-ui
   ```

1. Abra el navegador en la ubicación del paso anterior. Debería ver la interfaz de usuario de administración. El nodo **C** es el servicio cliente, el nodo **F** es el servicio frontend y el nodo **B** es el servicio backend. Cada nodo tiene acceso de comunicación completo a todos los demás nodos, como indican las líneas gruesas de colores.  
![\[Abra la política de red\]](http://docs.aws.amazon.com/es_es/eks/latest/userguide/images/stars-default.png)

1. Aplique la siguiente política de red en los espacios de nombres de `stars` y `client` para aislar los servicios entre sí:

   ```
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     name: default-deny
   spec:
     podSelector:
       matchLabels: {}
   ```

   Puede usar los siguientes comandos para aplicar la política a ambos espacios de nombres:

   ```
   kubectl apply -n stars -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/apply_network_policies.files/default-deny.yaml
   kubectl apply -n client -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/apply_network_policies.files/default-deny.yaml
   ```

1. Actualice su navegador. Verá que la interfaz de usuario de administración ya no tiene acceso a los nodos, que dejan de aparecer en la interfaz de usuario.

1. Aplique las siguientes políticas de red distintas para permitir el acceso de la interfaz de usuario de administración a los servicios. Aplique esta política para permitir la interfaz de usuario:

   ```
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     namespace: stars
     name: allow-ui
   spec:
     podSelector:
       matchLabels: {}
     ingress:
       - from:
           - namespaceSelector:
               matchLabels:
                 role: management-ui
   ```

   Aplique esta política para permitir el cliente:

   ```
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     namespace: client
     name: allow-ui
   spec:
     podSelector:
       matchLabels: {}
     ingress:
       - from:
           - namespaceSelector:
               matchLabels:
                 role: management-ui
   ```

   Puede usar los siguientes comandos para aplicar ambas políticas:

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/apply_network_policies.files/allow-ui.yaml
   kubectl apply -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/apply_network_policies.files/allow-ui-client.yaml
   ```

1. Actualice su navegador. Verá que la interfaz de usuario de administración tiene de nuevo acceso a los nodos, pero los nodos no pueden comunicarse entre sí.  
![\[Política de red para el acceso de la interfaz de usuario\]](http://docs.aws.amazon.com/es_es/eks/latest/userguide/images/stars-no-traffic.png)

1. Aplique la siguiente política de red para permitir el tráfico desde el servicio frontend hacia el servicio backend:

   ```
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     namespace: stars
     name: backend-policy
   spec:
     podSelector:
       matchLabels:
         role: backend
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 role: frontend
         ports:
           - protocol: TCP
             port: 6379
   ```

1. Actualice su navegador. Puede ver que el frontend puede comunicarse con el backend.  
![\[Política de frontend a backend\]](http://docs.aws.amazon.com/es_es/eks/latest/userguide/images/stars-front-end-back-end.png)

1. Aplique la siguiente política de red para permitir el tráfico desde el cliente hacia el servicio frontend:

   ```
   kind: NetworkPolicy
   apiVersion: networking.k8s.io/v1
   metadata:
     namespace: stars
     name: frontend-policy
   spec:
     podSelector:
       matchLabels:
         role: frontend
     ingress:
       - from:
           - namespaceSelector:
               matchLabels:
                 role: client
         ports:
           - protocol: TCP
             port: 80
   ```

1. Actualice su navegador. Verá que el cliente puede comunicarse con el servicio frontend. El servicio frontend puede seguir comunicándose con el servicio backend.  
![\[Política de red final\]](http://docs.aws.amazon.com/es_es/eks/latest/userguide/images/stars-final.png)

1. (Opcional) Cuando haya terminado con la demostración, puede eliminar sus recursos.

   ```
   kubectl delete -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/client.yaml
   kubectl delete -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/frontend.yaml
   kubectl delete -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/backend.yaml
   kubectl delete -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/management-ui.yaml
   kubectl delete -f https://raw.githubusercontent.com/aws-samples/eks-workshop/2f9d29ed3f82ed6b083649e975a0e574fb8a4058/content/beginner/120_network-policies/calico/stars_policy_demo/create_resources.files/namespace.yaml
   ```

   Incluso después de eliminar los recursos, todavía puede haber puntos de conexión de las políticas de red en los nodos que podrían interferir de manera inesperada con las redes en el clúster. La única forma segura de eliminar estas reglas es reiniciar los nodos o terminar todos los nodos y reciclarlos. Para terminar todos los nodos, establezca el recuento deseado del grupo de Auto Scaling en 0 y, a continuación, realice una copia de seguridad en el número deseado o simplemente termine los nodos.