Comando de creación en Kubernetes

Introducción

El comando kubectl create es una herramienta esencial para crear recursos de Kubernetes. Utiliza archivos YAML o JSON para definir recursos como namespaces, despliegues (deployments), servicios, secretos y ConfigMaps. En este laboratorio, aprenderás cómo crear estos recursos paso a paso y comprender su función en Kubernetes.

Al final de este laboratorio, podrás:

1. Iniciar y verificar un clúster de Minikube.
2. Crear y verificar varios recursos de Kubernetes utilizando kubectl create.

Skills Graph

Iniciar Minikube y Verificar el Clúster

Antes de trabajar con Kubernetes, necesitas un clúster en ejecución. Minikube proporciona un clúster local de Kubernetes ligero.

1. Navegar a tu directorio de proyecto:

   Abre tu terminal y navega al directorio de trabajo predeterminado:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicia Minikube para inicializar el clúster:

   minikube start

   • Minikube crea un clúster de Kubernetes de un solo nodo. Este paso puede tardar unos minutos.

3. Verificar el estado de Minikube:

   Comprueba si Minikube se inició correctamente:

   minikube status

   Busca componentes como apiserver y kubelet listados como Running (En ejecución).

4. Confirmar la configuración de Kubernetes:

   Asegúrate de que kubectl esté conectado al clúster de Minikube:

   kubectl cluster-info

   Esto muestra detalles sobre el servidor de API y otros componentes.

Si Minikube no se inicia correctamente, utiliza minikube delete para restablecerlo y vuelve a intentarlo.

Explorar el Comando kubectl create

El comando kubectl create proporciona múltiples subcomandos para crear recursos de Kubernetes. Ayuda a gestionar la creación de recursos como namespaces, despliegues (deployments), servicios, secretos y ConfigMaps.

Ejecuta el siguiente comando para ver los subcomandos disponibles de kubectl create:

kubectl create -h

Verás la siguiente salida:

Create a resource from a file or from stdin.

JSON and YAML formats are accepted.

Examples:
  ## Create a pod using the data in pod.json
  kubectl create -f./pod.json

  ## Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -

  ## Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json

Available Commands:
  clusterrole           Create a cluster role
  clusterrolebinding    Create a cluster role binding for a particular cluster role
  configmap             Create a config map from a local file, directory or literal value
  cronjob               Create a cron job with the specified name
  deployment            Create a deployment with the specified name
  ingress               Create an ingress with the specified name
  job                   Create a job with the specified name
  namespace             Create a namespace with the specified name
  poddisruptionbudget   Create a pod disruption budget with the specified name
  priorityclass         Create a priority class with the specified name
  quota                 Create a quota with the specified name
  role                  Create a role with single rule
  rolebinding           Create a role binding for a particular role or cluster role
  secret                Create a secret using specified subcommand
  service               Create a service using a specified subcommand
  serviceaccount        Create a service account with the specified name
  token                 Request a service account token

Revisa los subcomandos disponibles y sus descripciones para entender cómo se puede utilizar kubectl create.

Crear un Namespace

Los namespaces te permiten organizar y aislar recursos en Kubernetes.

1. Crear un archivo de definición de namespace:

   Abre un nuevo archivo llamado namespace.yaml:

   nano namespace.yaml

2. Definir el namespace:

   Agrega el siguiente contenido:

   apiVersion: v1
   kind: Namespace
   metadata:
     name: mynamespace

   Guarda el archivo presionando Ctrl+X, luego Y y Enter.

3. Aplicar el namespace:

   Crea el namespace:

   kubectl create -f namespace.yaml

4. Verificar el namespace:

   Comprueba la lista de namespaces:

   kubectl get namespaces

   Confirma que mynamespace aparezca en la salida.

Crear un Despliegue (Deployment)

Los despliegues (deployments) gestionan y mantienen el estado deseado de los pods.

1. Crear un archivo de definición de despliegue:

   Abre un archivo llamado deployment.yaml:

   nano deployment.yaml

2. Definir el despliegue:

   Agrega el siguiente contenido para desplegar tres réplicas de un contenedor Nginx:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: mydeployment
     namespace: mynamespace
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: myapp
     template:
       metadata:
         labels:
           app: myapp
       spec:
         containers:
           - name: nginx-container
             image: nginx

   Guarda el archivo.

3. Aplicar el despliegue:

   Crea el despliegue:

   kubectl create -f deployment.yaml

4. Verificar el despliegue:

   Comprueba el despliegue y sus pods:

   kubectl get deployments -n mynamespace
   kubectl get pods -n mynamespace

   Asegúrate de que tres pods estén en ejecución.

Crear un Servicio (Service)

Un servicio (service) proporciona acceso de red estable a un conjunto de pods.

1. Crear un archivo de definición de servicio:

   Abre un archivo llamado service.yaml:

   nano service.yaml

2. Definir el servicio:

   Agrega el siguiente contenido:

   apiVersion: v1
   kind: Service
   metadata:
     name: myservice
     namespace: mynamespace
   spec:
     selector:
       app: myapp
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80

   Guarda el archivo.

3. Aplicar el servicio:

   Crea el servicio:

   kubectl create -f service.yaml

4. Verificar el servicio:

   Comprueba la lista de servicios:

   kubectl get services -n mynamespace

   Confirma que myservice esté en la lista.

Crear un Secreto (Secret)

Los secretos (secrets) almacenan de forma segura información sensible como contraseñas o claves de API.

1. Crear un archivo de definición de secreto:

   Abre un archivo llamado secret.yaml:

   nano secret.yaml

2. Definir el secreto:

   Agrega el siguiente contenido con valores codificados en Base64:

   apiVersion: v1
   kind: Secret
   metadata:
     name: mysecret
     namespace: mynamespace
   type: Opaque
   data:
     username: dXNlcm5hbWU= ## Base64 for "username"
     password: cGFzc3dvcmQ= ## Base64 for "password"

   Guarda el archivo.

3. Aplicar el secreto:

   Crea el secreto:

   kubectl create -f secret.yaml

4. Verificar el secreto:

   Comprueba la lista de secretos:

   kubectl get secrets -n mynamespace

   Confirma que mysecret aparezca en la salida.

Crear un ConfigMap

Los ConfigMaps almacenan datos de configuración en pares clave - valor.

1. Crear un archivo de definición de ConfigMap:

   Abre un archivo llamado configmap.yaml:

   nano configmap.yaml

2. Definir el ConfigMap:

   Agrega el siguiente contenido:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: myconfigmap
     namespace: mynamespace
   data:
     database.host: "example.com"
     database.port: "5432"

   Guarda el archivo.

3. Aplicar el ConfigMap:

   Crea el ConfigMap:

   kubectl create -f configmap.yaml

4. Verificar el ConfigMap:

   Comprueba la lista de ConfigMaps:

   kubectl get configmaps -n mynamespace

   Confirma que myconfigmap aparezca en la salida.

Resumen

En este laboratorio, has aprendido cómo:

1. Iniciar y verificar un clúster de Minikube.
2. Crear recursos de Kubernetes como namespaces, despliegues (deployments), servicios (services), secretos (secrets) y ConfigMaps.
3. Verificar el estado de estos recursos.

Al dominar estos pasos, podrás gestionar y desplegar aplicaciones de manera efectiva en Kubernetes. ¡Practica estos pasos para fortalecer tu comprensión!