Configurar un Cluster de Kubernetes

lectura de 5 minutos prueba de página

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

Asegúrate de tener acceso a un Cluster de Kubernetes. Puedes usar el Google Kubernetes Engine o el IBM Cloud Kubernetes Service.
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
```
Crea el namespace:
```
$ kubectl create namespace $NAMESPACE
```
Si eres instructor, deberías asignar un namespace separado por cada participante. El tutorial soporta trabajo en múltiples namespaces simultáneamente por múltiples participantes.
Instala Istio usando el perfil demo.
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@
```
Si hay errores tratando de instalar los addons, intenta ejecutar el comando nuevamente. Puede que haya algunos problemas de temporización que se resolverán cuando el comando se ejecute nuevamente.

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

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

Crea una service account para cada participante:

$ kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ${NAMESPACE}-user
  namespace: $NAMESPACE
EOF

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

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

Establece la variable de entorno KUBECONFIG para el archivo de configuración ${NAMESPACE}-user-config.yaml:
```
$ export KUBECONFIG=$PWD/${NAMESPACE}-user-config.yaml
```
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.
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.