# Tutorial de Kubernetes

Kubernetes (también conocido como K8s) permite gestionar de forma eficiente grandes cantidades de contenedores y automatiza muchos procesos en el desarrollo de software. Con solo unos pocos pasos puedes instalar un clúster de Kubernetes potente y empezar a usarlo en producción de inmediato.

## Paso 1: prepara el sistema

En este tutorial te mostramos a modo de ejemplo la instalación de Kubernetes en [Ubuntu](https://www.ionos.com/digitalguide/server/know-how/ubuntu-the-linux-system-for-everyone/).

El primer paso consiste en preparar el sistema, actualizándolo a la versión más reciente e instalando todas las dependencias necesarias. Abre el **terminal** y ejecuta primero una actualización del sistema para asegurarte de que todos los paquetes estén al día:

```bash
sudo apt update && sudo apt upgrade -y
```

A continuación, instala los programas auxiliares más importantes que se requieren para la instalación de Kubernetes y Minikube. Para ello, utiliza el siguiente comando:

```bash
sudo apt install -y curl wget apt-transport-https ca-certificates gnupg lsb-release
```

Estas herramientas garantizan que puedas usar fuentes externas de forma segura y descargar e instalar otros paquetes de software sin problemas.

## Paso 2: instala kubectl

[Kubernetes](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-kubernetes/) trabaja con una gran variedad de servidores, llamados maestros (master) y nodos (nodes), que no tienen que estar ubicados en servidores físicos diferentes. Gracias al uso de [máquinas virtuales](https://www.ionos.com/es-us/digitalguide/servidores/know-how/maquina-virtual/), desde un ordenador se pueden activar varios nodos Kubernetes. Para probarlo, el programa gratuito [Minikube](https://www.ionos.com/es-us/digitalguide/servidores/herramientas/kubernetes-minikube/) es una buena opción, ya que permite trabajar con Kubernetes también de manera local. Dado que Minikube necesita una máquina virtual o [Docker](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-docker/), el programa depende de un [hipervisor](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-un-hypervisor/) o del software de contenedores. Además, es imprescindible contar con la herramienta kubectl.

Nota En este tutorial te mostramos cómo dar tus primeros pasos con Kubernetes utilizando Docker. Sin embargo, también puedes hacerlo con un software de virtualización como VirtualBox.

Primero, instala kubectl (Kube Control) en tu sistema. Este programa es necesario **para gestionar clústeres**.

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

Nota Los comandos de instalación dependen de la arquitectura de tu sistema.

## Paso 3: instala Docker

Antes de poder utilizar Minikube, debes asegurarte de que **Docker** esté instalado en tu sistema. Docker funciona como entorno de ejecución de contenedores y permite que Minikube ejecute [clústeres de Kubernetes](https://www.ionos.com/es-us/digitalguide/servidores/know-how/cluster-kubernetes/) sin necesidad de software de virtualización. Instala Docker con el siguiente comando:

```bash
sudo apt install -y docker.io
```

Para poder usar Docker sin permisos de administrador, añade tu cuenta de usuario al grupo docker:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Puede que necesites cerrar la sesión y volver a iniciarla para que la pertenencia al grupo se active. Por último, prueba la instalación con:

```bash
docker run hello-world
```

Si aparece un breve mensaje de éxito, significa que Docker se ha instalado correctamente y está listo para usarse con Minikube.

## Paso 4: instala y arranca Minikube

En el siguiente paso, se instala Minikube en una versión compatible y se utiliza Docker como controlador. Primero, descarga la versión adecuada de Minikube, haz que el archivo sea ejecutable y muévelo a un directorio del sistema para que el comando esté disponible de forma global:

```bash
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
chmod +x minikube-linux-arm64
sudo mv minikube-linux-arm64 /usr/local/bin/minikube
```

Después de la instalación, puedes comprobar con el siguiente comando si Minikube se ha configurado correctamente:

```bash
minikube version
```

A continuación, inicia Minikube con el siguiente comando:

```bash
minikube start --driver=docker
```

En este escenario, Minikube utiliza Docker como **entorno de ejecución de contenedores** y crea el clúster de Kubernetes directamente dentro del entorno de Docker. Al iniciar Minikube, kubectl debería configurarse automáticamente de forma correcta. Para pasar de la línea de comandos a una interfaz gráfica de usuario ([GUI](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/que-es-una-gui/)), introduce otro comando. Este abrirá el **Dashboard** en el navegador predeterminado:

```bash
minikube dashboard
```

[![Imagen: Panel de control de Kubernetes](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/6/7/csm_kubernetes-dashboard_549c1e7bb8.webp "Panel de control de Kubernetes")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-dashboard.jpg) Panel de control de Kubernetes vacío ## Paso 5: usa Kubernetes

Una vez iniciado Minikube, el programa creará automáticamente un **clúster** con un único nodo. Puedes comprobarlo introduciendo un comando para kubectl:

```bash
kubectl get nodes
```

Ahora ya puedes **crear despliegues (deployments)** desde el panel de control. Para ello, haz clic en la opción “Crear” (el signo “+” arriba a la derecha) y aparecerá un editor web en el que podrás crear un despliegue en formato [JSON](https://www.ionos.com/es-us/digitalguide/servidores/know-how/que-es-json/) o [YAML](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/yaml-el-ligero-framework-css-para-expertos/). Al hacerlo, Kubernetes generará automáticamente varios pods (grupos de contenedores), cuya cantidad puede modificarse **escalando el despliegue**. La función correspondiente se encuentra sobre el icono de tres puntos junto al despliegue.

[![Imagen: Panel de control de Kubernetes con dos despliegues y cuatro pods](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/f/9/csm_kubernetes-overview-deployment-pods_70f88067c3.webp "Panel de control de Kubernetes con dos despliegues y cuatro pods")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-overview-deployment-pods.jpg) El panel de control ofrece una visión general de todos los despliegues y pods. [![Imagen: Cómo escalar un despliegue en Kubernetes](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/3/b/csm_kubernetes-scale-resources_a09c6390b2.webp "Cómo escalar un despliegue en Kubernetes")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-scale-resources.jpg) Cómo escalar un despliegue en Kubernetes Otra opción es crear despliegues a través de la terminal. Para ello, sin embargo, los contenidos han de estar ya integrados en una [imagen Docker](https://www.ionos.com/es-us/digitalguide/servidores/know-how/docker-image/) guardada en un repositorio.

```bash
kubectl create deployment --image=[Ruta a la imagen]
```

En la terminal de comandos pueden solicitarse numerosas informaciones:

**¿Qué despliegues existen?**

```bash
kubectl get deployments
```

**¿Cuántos pods hay?**

```bash
kubectl get pods
```

**¿Qué servicios hay?**

```bash
kubectl get services
```

**¿Qué nodos están activos?**

```bash
kubectl get nodes
```

[![Imagen: Terminal con varios comandos y resultados de Kubernetes](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/f/5/csm_screenshot-kubernetes-ubuntu-terminal_4c2f4d2127.webp "Terminal con varios comandos y resultados de Kubernetes")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/screenshot-kubernetes-ubuntu-terminal.jpg) Comandos de Kubernetes en la terminal ## Paso 6: publica un despliegue (deployment)

Llegados a este punto, hemos iniciado el despliegue, pero aún no lo hemos publicado. Para hacerlo, hay que crear un **servicio** (service):

```bash
kubectl expose deploy test-deployment
```

De este modo, sin embargo, el servicio solo se ha publicado dentro del clúster. Para poder acceder al despliegue también **desde fuera del clúster**, hay que añadir flags adicionales:

```bash
kubectl expose deploy test-deployment --type=LoadBalancer --port=8080
```

A continuación, ya se puede iniciar el servicio con Minikube:

```bash
minikube service test-deployment
```

También existe un comando para eliminar el servicio:

```bash
kubectl delete service test-deployment
```

E, igualmente, uno para eliminar el despliegue:

```bash
kubectl delete deployment test-deployment
```

Finalmente, para cerrar Minikube, hay que detener el proceso:

```bash
minikube stop
```

Y, si ya no quieres seguir trabajando con la máquina virtual o con el entorno de ejecución de contenedores, puede eliminarlos fácilmente:

```bash
minikube delete
```

Al hacerlo, también se eliminan tanto la configuración previa como los despliegues y pods creados, de manera que, si se vuelve a iniciar Minikube, se empieza de nuevo con un clúster vacío.


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/servidores/configuracion/tutorial-de-kubernetes/](https://www.ionos.com/es-us/digitalguide/servidores/configuracion/tutorial-de-kubernetes/) for AI/LLM consumption.