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:

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

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.

Navegar a tu directorio de proyecto:

Abre tu terminal y navega al directorio de trabajo predeterminado:
```
cd /home/labex/project
```
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.
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).
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.

Crear un archivo de definición de namespace:

Abre un nuevo archivo llamado namespace.yaml:
```
nano namespace.yaml
```
Definir el namespace:

Agrega el siguiente contenido:
```
apiVersion: v1
kind: Namespace
metadata:
  name: mynamespace
```
Guarda el archivo presionando Ctrl+X, luego Y y Enter.
Aplicar el namespace:

Crea el namespace:
```
kubectl create -f namespace.yaml
```
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.

Crear un archivo de definición de despliegue:

Abre un archivo llamado deployment.yaml:
```
nano deployment.yaml
```

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.

Aplicar el despliegue:

Crea el despliegue:
```
kubectl create -f deployment.yaml
```
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.

Crear un archivo de definición de servicio:

Abre un archivo llamado service.yaml:
```
nano service.yaml
```

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.

Aplicar el servicio:

Crea el servicio:
```
kubectl create -f service.yaml
```
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.

Crear un archivo de definición de secreto:

Abre un archivo llamado secret.yaml:
```
nano secret.yaml
```

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.

Aplicar el secreto:

Crea el secreto:
```
kubectl create -f secret.yaml
```
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.

Crear un archivo de definición de ConfigMap:

Abre un archivo llamado configmap.yaml:
```
nano configmap.yaml
```

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.

Aplicar el ConfigMap:

Crea el ConfigMap:
```
kubectl create -f configmap.yaml
```
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:

Iniciar y verificar un clúster de Minikube.
Crear recursos de Kubernetes como namespaces, despliegues (deployments), servicios (services), secretos (secrets) y ConfigMaps.
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!