Implementa una app de servidor web alojada en contenedores

Crea un registro de Harbor administrado

GDC con aislamiento de aire proporciona Harbor como servicio, que es un servicio completamente administrado que te permite almacenar y administrar imágenes de contenedores con Harbor.

Para usar Harbor como servicio, primero debes crear una instancia del registro de Harbor y un proyecto de Harbor.

Crea una instancia de registro de Harbor

Para crear una instancia del registro de contenedores de Harbor, completa los siguientes pasos:

Crea un proyecto de Harbor en el registro

Debes crear un proyecto de Harbor dentro de la instancia del registro de Harbor para administrar tus imágenes de contenedor:

Configura el Docker

Para usar Docker en tu registro de Harbor, completa los siguientes pasos:

1. Configura Docker para que confíe en Harbor como servicio. Para obtener más información, consulta Configura Docker para que confíe en la CA raíz de Harbor.

2. Configura la autenticación de Docker en Harbor. Para obtener más información, consulta Configura la autenticación de Docker en instancias del registro de Harbor.

Crea un secreto de extracción de imágenes de Kubernetes

Como usas un proyecto privado de Harbor, debes crear un secreto de extracción de imágenes de Kubernetes.

1. Agrega una cuenta de robot del proyecto de Harbor para que actúe como tu cuenta de servicio.

   1. En la consola de Harbor, selecciona tu proyecto de Harbor.

   2. Haz clic en Cuentas de robot.

   3. Selecciona New Robot Account.

   4. Asigna un nombre a tu nueva cuenta de robot y define cualquier parámetro de configuración adicional.

   5. Haz clic en Agregar.

   6. El nombre y el secreto de la cuenta del robot se muestran en la pantalla de éxito. Mantén esta pantalla abierta para consultarla en el próximo paso.

   Para obtener más información, consulta la documentación de Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.

2. En una nueva ventana de la terminal, accede a Docker con la cuenta de robot y el token secreto de tu proyecto de Harbor:

   docker login ${INSTANCE_URL}
   

   Cuando se te solicite, inserta el nombre del proyecto del robot en Nombre de usuario y el token secreto en Contraseña que se proporcionaron en el paso anterior desde la pantalla de éxito de la consola de Harbor.

3. Establece un nombre arbitrario para el secreto de extracción de imágenes:

   export SECRET=SECRET
   

4. Crea el secreto necesario para extraer la imagen:

   kubectl create secret docker-registry ${SECRET}  \
       --from-file=.dockerconfigjson=DOCKER_CONFIG \
       -n ${NAMESPACE}
   

   Reemplaza DOCKER_CONFIG por la ruta de acceso al archivo .docker/config.json.

5. Confirma que tu secreto exista en el espacio de nombres de tu proyecto de GDC:

   kubectl get secrets -n ${NAMESPACE}
   

   El resultado es similar a este:

   NAME          TYPE                               DATA     AGE
   my-secret     kubernetes.io/dockerconfigjson     1        23s
   

Envía la imagen del contenedor al registro de Harbor administrado

En este instructivo, descargarás y enviarás la imagen del servidor web nginx al registro administrado de Harbor, y la usarás para implementar una app de servidor web nginx de muestra en un clúster de Kubernetes. La app del servidor web nginx está disponible en el repositorio público de Docker Hub.

1. Extrae la imagen nginx de Docker Hub a tu estación de trabajo local a través de una red externa:

   docker pull nginx
   

2. Etiqueta la imagen local con el nombre del repositorio:

   docker tag nginx ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
   

3. Envía la imagen del contenedor nginx a tu registro de Harbor administrado:

   docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
   

Crea un clúster de Kubernetes

Ahora que tienes la imagen del contenedor nginx almacenada en el registro de Harbor administrado y puedes acceder a ella, crea un clúster de Kubernetes para ejecutar el servidor web nginx.

Para obtener más información sobre cómo crear un clúster de Kubernetes, consulta Crea un clúster de Kubernetes.

Implementa la app de contenedor de muestra

Ahora ya puedes implementar la imagen del contenedor nginx en tu clúster de Kubernetes.

Kubernetes representa las aplicaciones como recursos Pod, que son unidades escalables que contienen uno o más contenedores. El Pod es la unidad más pequeña que se puede implementar en Kubernetes. Por lo general, implementas los Pods como un conjunto de réplicas que se pueden escalar y distribuir juntas en el clúster. Una forma de implementar un conjunto de réplicas es a través de un Deployment de Kubernetes.

En esta sección, crearás un Deployment de Kubernetes para ejecutar la app de contenedor nginx en tu clúster. Esta implementación tiene réplicas o Pods. Un pod Deployment contiene solo un contenedor: la imagen de contenedor nginx. También crearás un recurso Service que proporcione una forma estable para que los clientes envíen solicitudes a los pods de tu Deployment.

Implementa el servidor web NGINX en tu clúster de Kubernetes:

1. Accede al clúster de Kubernetes y genera su archivo kubeconfig con una identidad de usuario. Establece la ruta de kubeconfig como una variable de entorno:

   export KUBECONFIG=CLUSTER_KUBECONFIG_PATH
   

2. Crea e implementa los recursos personalizados Deployment y Service de Kubernetes:

   kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
   create -f - <<EOF
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx-deployment
     labels:
       app: nginx
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - name: nginx
           image: ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
           ports:
           - containerPort: 80
         imagePullSecrets:
         - name: ${SECRET}
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: nginx-service
   spec:
     selector:
       app: nginx
     ports:
       - port: 80
         protocol: TCP
     type: LoadBalancer
   EOF
   

3. Verifica que la implementación haya creado los pods:

   kubectl get pods -l app=nginx -n ${NAMESPACE}
   

   El resultado es similar a este:

   NAME                                READY     STATUS    RESTARTS   AGE
   nginx-deployment-1882529037-6p4mt   1/1       Running   0          1h
   nginx-deployment-1882529037-p29za   1/1       Running   0          1h
   nginx-deployment-1882529037-s0cmt   1/1       Running   0          1h
   

4. Crea una política de red para permitir todo el tráfico de red al espacio de nombres:

   kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
   create -f - <<EOF
   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     annotations:
     name: allow-all
   spec:
     ingress:
     - from:
       - ipBlock:
           cidr: 0.0.0.0/0
     podSelector: {}
     policyTypes:
     - Ingress
   EOF
   

5. Exporta la dirección IP del servicio nginx:

     export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
         -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`
   

6. Prueba la dirección IP del servidor nginx con curl:

     curl http://$IP