Se usó la API de Cloud Translation para traducir esta página.

Implementa una app de servidor web alojada en contenedores

En este instructivo, se describe cómo subir una aplicación en contenedor a un entorno de dispositivo aislado de Google Distributed Cloud (GDC) y ejecutarla en ese entorno. En este instructivo, aprenderás a crear proyectos de Harbor, subir imágenes a Harbor y crear cargas de trabajo. Una carga de trabajo en contenedores se ejecuta dentro de un espacio de nombres del proyecto.

El entorno de dispositivo aislado de GDC incluye un registro de Harbor preconfigurado llamado tear-harbor en un proyecto de GDC llamado tear. Usarás este registro en este ejemplo.

En este instructivo, se usa una app de servidor web de muestra disponible en Google CloudArtifact Registry.

Objetivos

Envía una imagen de contenedor al registro de Harbor administrado.
Implementa la app de contenedor de muestra en el clúster.

Antes de comenzar

Asegúrate de tener un proyecto para administrar tus implementaciones en contenedores. Crea un proyecto si no tienes uno.
Configura el espacio de nombres de tu proyecto como una variable de entorno:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Descarga y, luego, instala la CLI de gdcloud.
Pídele al administrador de IAM de tu organización que te otorgue los siguientes roles:
- Rol de administrador de espacio de nombres (namespace-admin) para el espacio de nombres de tu proyecto Este rol es necesario para implementar cargas de trabajo de contenedores en tu proyecto.
- Rol de visualizador de instancias de Harbor (harbor-instance-viewer) para el espacio de nombres de tu proyecto Este rol es obligatorio para ver y seleccionar una instancia de Harbor.
- Rol de creador del proyecto de Harbor (harbor-project-creator) para el espacio de nombres de tu proyecto Este rol es necesario para acceder a un proyecto de Harbor y administrarlo.
Accede al clúster de Kubernetes y genera su archivo kubeconfig con una identidad de usuario. Asegúrate de establecer la ruta de kubeconfig como una variable de entorno:
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Crea un proyecto de Harbor en el registro

GDC 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, debes crear un proyecto de Harbor dentro de la instancia del registro tear-harbor para administrar tus imágenes de contenedor:

Necesitas la URL de tear-harbor. Enumera la URL de la instancia:
```
gdcloud harbor instances describe tear-harbor --project=tear
```
El resultado es similar a harbor-1.org-1.zone1.google.gdc.test.
Configura la URL de la instancia como una variable para usarla más adelante en el instructivo:
```
export INSTANCE_URL=INSTANCE_URL
```
Antes de crear el proyecto, debes acceder a Harbor con la URL del paso anterior. Usa un navegador para abrir esta URL y acceder a la instancia de Harbor.
Crea el proyecto de Harbor:
```
gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=tear \
    --instance=tear-harbor
```
Reemplaza HARBOR_PROJECT por el nombre del proyecto de Harbor que deseas crear. No puedes crear el proyecto de Harbor en ningún espacio de nombres del proyecto. Debes usar el proyecto tear.
Establece el nombre del proyecto de Harbor como una variable para usarla más adelante en el instructivo:
```
export HARBOR_PROJECT=HARBOR_PROJECT
```

Configura el Docker

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

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.
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.
Dado que tear-harbor es un registro de Harbor preconfigurado, debes confiar en el certificado firmado por la CA interna aislada de Google Distributed Cloud:
1. Pídele a tu IO la siguiente información:
  1. Es la URL externa del clúster de Harbor.
  2. El archivo .crt de la CA interna aislada de Google Distributed Cloud Por lo general, el archivo se almacena en el plano de control como un secreto con el nombre trust-store-internal-only en el espacio de nombres anthos-creds.
2. De manera similar al paso anterior, crea una carpeta con el nombre de la URL externa del clúster de Harbor y guarda el archivo .crt dentro de la carpeta.

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.

Agrega una cuenta de robot del proyecto de Harbor. Sigue los pasos de la IU de Harbor para crear la cuenta de robot y copiar el token secreto del robot: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.
Ten en cuenta el nuevo nombre de la cuenta del proyecto del robot, que tiene la siguiente sintaxis:
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Por ejemplo, el formato del nombre de la cuenta del proyecto de robot se parece a harbor@library+artifact-account.

Para obtener más información sobre cómo encontrar el nombre de la cuenta del proyecto de robot en Harbor, consulta la documentación de Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#view-project-robot-accounts.
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 de la cuenta del proyecto del robot para Username y el token secreto para Password.
Establece un nombre arbitrario para el secreto de extracción de imágenes:
```
export SECRET=SECRET
```
Crea el secreto necesario para extraer la imagen:
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Reemplaza lo siguiente:
- DOCKER_CONFIG: Es la ruta de acceso al archivo .docker/config.json.
- NAMESPACE: Es el espacio de nombres del secreto que creas.

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 Google Cloud Artifact Registry público.

Extrae la imagen nginx de Google Cloud Artifact Registry a tu estación de trabajo local a través de una red externa:
```
docker pull gcr.io/cloud-marketplace/google/nginx:1.25
```
Establece el nombre de la imagen. El formato de un nombre de imagen completo es el siguiente:
```
${INSTANCE_URL}/${HARBOR_PROJECT}/nginx
```

Etiqueta la imagen local con el nombre del repositorio:

docker tag gcr.io/cloud-marketplace/google/nginx:1.25 ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Envía la imagen del contenedor nginx a tu registro de Harbor administrado:
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Implementa la app de contenedor de muestra

Ahora ya puedes implementar la imagen del contenedor nginx en el clúster del dispositivo.

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:

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

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

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

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}'`

Prueba la dirección IP del servidor nginx con curl:
```
  curl http://$IP
```

¿Qué sigue?

Lee la documentación sobre contenedores para obtener información sobre cómo administrarlos.