# Prueba tu despliegue de Java


## Prerrequisitos

- Completa todas las secciones anteriores de esta guía, comenzando con [Contenerizar tu aplicación](/guides/java/deploy/containerize/).
- [Activa Kubernetes](/desktop/use-desktop/kubernetes/#enable-kubernetes) en Docker Desktop.

## Descripción general

En esta sección, aprenderás cómo usar Docker Desktop para desplegar tu
aplicación en un entorno Kubernetes con todas las funciones en tu máquina de desarrollo.
Esto te permite probar y depurar tus cargas de trabajo en Kubernetes localmente
antes de desplegarlas.

## Crear un archivo YAML de Kubernetes

En tu directorio `spring-petclinic`, crea un archivo llamado
`docker-java-kubernetes.yaml`. Abre el archivo en un IDE o editor de texto y agrega
el siguiente contenido. Reemplaza `DOCKER_USERNAME/REPO_NAME` con tu nombre de usuario de Docker
y el nombre del repositorio que creaste en [Configurar CI/CD para
tu aplicación Java](/guides/java/deploy/configure-ci-cd/).

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: docker-java-demo
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      service: server
  template:
    metadata:
      labels:
        service: server
    spec:
      containers:
        - name: server-service
          image: DOCKER_USERNAME/REPO_NAME
          imagePullPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: service-entrypoint
  namespace: default
spec:
  type: NodePort
  selector:
    service: server
  ports:
    - port: 8080
      targetPort: 8080
      nodePort: 30001
```

En este archivo YAML de Kubernetes, hay dos objetos, separados por `---`:

- Un Deployment, que describe un grupo escalable de pods idénticos. En este caso,
  obtendrás solo una réplica, o copia de tu pod. Ese pod, que se
  describe bajo `template`, tiene solo un contenedor dentro. El
  contenedor se crea a partir de la imagen construida por GitHub Actions en [Configurar CI/CD para
  tu aplicación Java](/guides/java/deploy/configure-ci-cd/).
- Un servicio NodePort, que enrutará el tráfico desde el puerto 30001 de tu host al
  puerto 8080 dentro de los pods a los que se dirige, lo que te permite acceder a tu aplicación
  desde la red.

Para aprender más sobre los objetos de Kubernetes, consulta la [documentación de Kubernetes](https://kubernetes.io/docs/home/).

## Desplegar y comprobar tu aplicación

1. En una terminal, navega a `spring-petclinic` y despliega tu aplicación en
   Kubernetes.

   ```console
   $ kubectl apply -f docker-java-kubernetes.yaml
   ```

   Deberías ver una salida similar a la siguiente, indicando que tus objetos de Kubernetes se crearon correctamente.

   ```shell
   deployment.apps/docker-java-demo created
   service/service-entrypoint created
   ```

2. Asegúrate de que todo haya funcionado listando tus despliegues.

   ```console
   $ kubectl get deployments
   ```

   Tu despliegue debería aparecer de la siguiente manera:

   ```shell
   NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
   docker-java-demo     1/1     1            1           15s
   ```

   Esto indica que el único pod que solicitaste en tu YAML está en funcionamiento. Realiza la misma comprobación para tus servicios.

   ```console
   $ kubectl get services
   ```

   Deberías obtener una salida como la siguiente.

   ```shell
   NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   kubernetes           ClusterIP   10.96.0.1       <none>        443/TCP          23h
   service-entrypoint   NodePort    10.99.128.230   <none>        8080:30001/TCP   75s
   ```

   Además del servicio predeterminado `kubernetes`, puedes ver tu servicio `service-entrypoint`, aceptando tráfico en el puerto 30001/TCP.

3. En una terminal, haz un curl al servicio. Ten en cuenta que no se desplegó una base de datos en
   este ejemplo.

   ```console
   $ curl --request GET \
     --url http://localhost:30001/actuator/health \
     --header 'content-type: application/json'
   ```

   Deberías obtener una salida como la siguiente.

   ```console
   {"status":"UP","groups":["liveness","readiness"]}
   ```

4. Ejecuta el siguiente comando para eliminar tu aplicación.

   ```console
   $ kubectl delete -f docker-java-kubernetes.yaml
   ```

## Resumen

En esta sección, aprendiste cómo usar Docker Desktop para desplegar tu aplicación en un entorno Kubernetes con todas las funciones en tu máquina de desarrollo.

Información relacionada:

- [Documentación de Kubernetes](https://kubernetes.io/docs/home/)
- [Desplegar en Kubernetes con Docker Desktop](/desktop/use-desktop/kubernetes/)
- [Descripción general del modo Swarm](/engine/swarm/)