Configurar un Cluster de Kubernetes

En este módulo, configuras un Cluster de Kubernetes que tiene Istio instalado y un namespace para usar durante todo el tutorial.

  1. Asegúrate de tener acceso a un Cluster de Kubernetes. Puedes usar el Google Kubernetes Engine o el IBM Cloud Kubernetes Service.

  2. Crea una variable de entorno para almacenar el nombre de un namespace que usarás cuando ejecutes los comandos del tutorial. Puedes usar cualquier nombre, por ejemplo tutorial.

    $ export NAMESPACE=tutorial
  3. Crea el namespace:

    $ kubectl create namespace $NAMESPACE
  4. Instala Istio usando el perfil demo.

  5. Los addons Kiali y Prometheus se usan en este ejemplo y necesitan ser instalados. Todos los addons se instalan usando:

    Zip
    $ kubectl apply -f @samples/addons@
  6. Crea un recurso Kubernetes Ingress para estos servicios comunes de Istio usando el comando kubectl mostrado. No es necesario estar familiarizado con cada uno de estos servicios en este punto del tutorial.

    El comando kubectl puede aceptar una configuración en línea para crear los recursos Ingress para cada servicio:

    $ kubectl apply -f - <<EOF
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      name: istio-system
      namespace: istio-system
      annotations:
        kubernetes.io/ingress.class: istio
    spec:
      rules:
      - host: my-istio-dashboard.io
        http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: grafana
                port:
                  number: 3000
      - host: my-istio-tracing.io
        http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: tracing
                port:
                  number: 9411
      - host: my-istio-logs-database.io
        http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: prometheus
                port:
                  number: 9090
      - host: my-kiali.io
        http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: kiali
                port:
                  number: 20001
    EOF
  7. Crea un rol para proporcionar acceso de lectura al namespace istio-system. Este rol es requerido para limitar los permisos de los participantes en los pasos a continuación.

    $ kubectl apply -f - <<EOF
    kind: Role
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: istio-system-access
      namespace: istio-system
    rules:
    - apiGroups: ["", "extensions", "apps"]
      resources: ["*"]
      verbs: ["get", "list"]
    EOF
  8. Crea una service account para cada participante:

    $ kubectl apply -f - <<EOF
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: ${NAMESPACE}-user
      namespace: $NAMESPACE
    EOF
  9. Limita los permisos de cada participante. Durante el tutorial, los participantes solo necesitan crear recursos en su namespace y leer recursos del namespace istio-system. Es una buena práctica, incluso si usas tu propio cluster, evitar interferir con otros namespaces en tu cluster.

    Crea un rol para permitir acceso de lectura-escritura al namespace de cada participante. Vincula la cuenta de servicio del participante a este rol y al rol para leer recursos desde istio-system:

    $ kubectl apply -f - <<EOF
    kind: Role
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: ${NAMESPACE}-access
      namespace: $NAMESPACE
    rules:
    - apiGroups: ["", "extensions", "apps", "networking.k8s.io", "networking.istio.io", "authentication.istio.io",
                  "rbac.istio.io", "config.istio.io", "security.istio.io"]
      resources: ["*"]
      verbs: ["*"]
    ---
    kind: RoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: ${NAMESPACE}-access
      namespace: $NAMESPACE
    subjects:
    - kind: ServiceAccount
      name: ${NAMESPACE}-user
      namespace: $NAMESPACE
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: Role
      name: ${NAMESPACE}-access
    ---
    kind: RoleBinding
    apiVersion: rbac.authorization.k8s.io/v1
    metadata:
      name: ${NAMESPACE}-istio-system-access
      namespace: istio-system
    subjects:
    - kind: ServiceAccount
      name: ${NAMESPACE}-user
      namespace: $NAMESPACE
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: Role
      name: istio-system-access
    EOF
  10. Cada participante necesita usar su propio archivo de configuración de Kubernetes. Este archivo de configuración especifica los detalles del cluster, la service account, las credenciales y el namespace del participante. El comando kubectl usa el archivo de configuración para operar en el cluster.

    Genera un archivo de configuración de Kubernetes para cada participante:

    $ cat <<EOF > ./${NAMESPACE}-user-config.yaml
    apiVersion: v1
    kind: Config
    preferences: {}
    
    clusters:
    - cluster:
        certificate-authority-data: $(kubectl get secret $(kubectl get sa ${NAMESPACE}-user -n $NAMESPACE -o jsonpath={.secrets..name}) -n $NAMESPACE -o jsonpath='{.data.ca\.crt}')
        server: $(kubectl config view -o jsonpath="{.clusters[?(.name==\"$(kubectl config view -o jsonpath="{.contexts[?(.name==\"$(kubectl config current-context)\")].context.cluster}")\")].cluster.server}")
      name: ${NAMESPACE}-cluster
    
    users:
    - name: ${NAMESPACE}-user
      user:
        as-user-extra: {}
        client-key-data: $(kubectl get secret $(kubectl get sa ${NAMESPACE}-user -n $NAMESPACE -o jsonpath={.secrets..name}) -n $NAMESPACE -o jsonpath='{.data.ca\.crt}')
        token: $(kubectl get secret $(kubectl get sa ${NAMESPACE}-user -n $NAMESPACE -o jsonpath={.secrets..name}) -n $NAMESPACE -o jsonpath={.data.token} | base64 --decode)
    
    contexts:
    - context:
        cluster: ${NAMESPACE}-cluster
        namespace: ${NAMESPACE}
        user: ${NAMESPACE}-user
      name: ${NAMESPACE}
    
    current-context: ${NAMESPACE}
    EOF
  11. Establece la variable de entorno KUBECONFIG para el archivo de configuración ${NAMESPACE}-user-config.yaml:

    $ export KUBECONFIG=$PWD/${NAMESPACE}-user-config.yaml
  12. Verifica que la configuración surtió efecto imprimiendo el namespace actual:

    $ kubectl config view -o jsonpath="{.contexts[?(@.name==\"$(kubectl config current-context)\")].context.namespace}"
    tutorial

    Deberías ver el nombre de tu namespace en la salida.

  13. Si estás configurando el cluster para ti mismo, copia el archivo ${NAMESPACE}-user-config.yaml mencionado en los pasos anteriores a tu computadora local, donde ${NAMESPACE} es el nombre del namespace que proporcionaste en los pasos anteriores. Por ejemplo, tutorial-user-config.yaml. Necesitarás este archivo más tarde en el tutorial.

    Si eres instructor, envía los archivos de configuración generados a cada participante. Los participantes deben copiar su archivo de configuración a su computadora local.

¡Felicidades, configuraste tu cluster para el tutorial!

Estás listo para configurar una computadora local.

¿Fue útil esta información?
¿Tienes alguna sugerencia para mejorar?

¡Gracias por tus comentarios!