Cómo implementar servicios web en OpenShift

OpenShift es una plataforma poderosa que permite a los usuarios administrar y escalar fácilmente aplicaciones en entornos en contenedores. Si bien OpenShift es una gran herramienta con muchas capacidades diferentes, este tutorial se enfoca en hacer lo mínimo para que la API esté activa y expuesta en el clúster.

[ Learn everything you need to know about Kubernetes. ]

Este tutorial asume que tiene conocimientos básicos de motores de contenedores y desarrollo de API.

requisitos previos

Asegúrese de que se cumplan los siguientes requisitos previos para realizar los pasos de este tutorial:

Las secciones anteriores de esta guía cubrieron cómo contener y publicar su aplicación en un registro de imágenes.Si desea utilizar la aplicación de muestra vinculada anteriormente y omitir estos pasos, vaya a crear despliegue.

Contenga su aplicación

Así que ha desarrollado un servicio web, ¿ahora qué? Primero, debe agregar un Containerfile a la raíz de su proyecto para que Podman pueda crear correctamente la imagen del contenedor para su aplicación. El contenido exacto del Containerfile dependerá de su aplicación, pero aquí hay un ejemplo de la aplicación de muestra que estoy usando:

FROM golang:alpine AS build-env
RUN mkdir /go/src/app && apk update && apk add git
ADD main.go go.mod go.sum /go/src/app/
WORKDIR /go/src/app
RUN go mod download && CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

FROM scratch
WORKDIR /app
COPY --from=build-env /go/src/app/app .
ENTRYPOINT ["./app"]

En este caso se utiliza una construcción de varias etapas. Tenga en cuenta que creó dos imágenes en este Containerfile. La primera imagen contiene las herramientas necesarias para construir y compilar la aplicación. Después de compilar su aplicación, ya no necesita depender de ninguna de estas herramientas de compilación y puede copiar los artefactos en una imagen de «borrador» vacía. Esto hace que la imagen sea más pequeña, lo que significa tiempos de carga más rápidos en el clúster, y la imagen es más segura porque no se comprometen las herramientas persistentes.

[ Download now: Podman basics cheat sheet ]

Ahora está listo para construir la imagen. Haga esto ejecutando el siguiente comando en Terminal desde el directorio raíz del proyecto:

$ podman build . -t web-service-gin --platform linux/amd64
…
Successfully tagged quay.io/avulaj/web-service-gin:latest
acd11248b7c2140245d06f3ace4418076201a82642852cf0b01ed8185e580603

• podman build es el comando raíz.
• El siguiente parámetro indica el directorio donde reside su Containerfile.utilizar . Porque actualmente se encuentra en el directorio raíz de su proyecto.
• -t Indica el nombre que se le asignará a la imagen.En este caso, elija web-service-gin.
• --platform especifica que eres linux/amd64, que es necesario para los pods de OpenShift. Tenga en cuenta que esto aumentará el tiempo que se tarda en crear la imagen si se ejecuta en una plataforma diferente.

Como se muestra arriba, este comando debería generar la ID de la imagen. Tome nota de esta identificación, ya que la necesitará más adelante.

Ahora puede usar esta imagen para probar su aplicación localmente en un contenedor de Podman. Haga esto con el siguiente comando:

$ podman run -d --rm -p8080:8080 

• podman run es el comando raíz.
• -d es opcional y ejecuta el contenedor en segundo plano. Sin esta bandera, necesitará una terminal separada para ejecutar el comando.
• --rm es opcional y le dice a Podman que elimine automáticamente el contenedor después de que salga.
• -p Especifica el puerto del contenedor (o rango de puertos) para publicar en el host. Esto dependerá de cómo esté estructurada su aplicación. En mi caso, expuse mi aplicación en el puerto 8080 y la publiqué en el host.
• image_id es el ID proporcionado después de crear la imagen.Si pierde esta identificación, puede ejecutar podman images Consíguelo de nuevo.

Este comando generará un ID de contenedor; lo necesitará más adelante para limpiar los contenedores en ejecución.

En este punto, su API debería estar disponible en localhost en su máquina. Por ejemplo, si ha estado usando mi aplicación de muestra a lo largo de este tutorial, debería ver el siguiente resultado:

$ curl localhost:8080
"Hello"

¡Felicidades! Ha colocado correctamente su aplicación en contenedores y está listo para pasar al siguiente paso. Puede detener el contenedor de forma segura con el siguiente comando:

$ podman stop 

[ Want to test your sysadmin skills? Take a skills assessment today. ]

publica tu foto

Ahora que ha creado una imagen para su aplicación, debe publicarla en algún lugar para poder usarla para crear una implementación de OpenShift. Para este tutorial, usará Quay.Si tienes un cuenta de muelle, inicie sesión inmediatamente. De lo contrario, crea uno nuevo.

Una vez que haya iniciado sesión en la consola web, cree un nuevo repositorio público con el nombre que desee. Después de crear el repositorio, inserte la imagen en él con:

$ podman push  quay.io//:

• podman push es el comando raíz.
• Reemplace con el ID de la imagen que creó en la sección anterior.
• es su nombre de usuario en quay.io.
• es el nombre que eliges para tu repositorio.
• es una etiqueta personalizada para identificar su imagen. Esto puede ser cualquier cosa que elija para identificar la imagen en el repositorio.En caso de duda, siga Versionado semántico por seguridad.

crear despliegue

Así que ha creado su API REST, la ha colocado en un contenedor e incluso la ha publicado en un registro de imágenes. Ahora viene la parte divertida: implementar la aplicación en el clúster de OpenShift.

En OpenShift, un objeto de implementación describe cómo se crea o modifica un pod que alberga una aplicación en contenedor al definir el estado deseado de un componente en particular. Implementación Crea y administra cómo se implementan los ReplicaSets. Los ReplicaSets orquestan el ciclo de vida de los pods y garantizan la disponibilidad de un número específico de pods idénticos. Las implementaciones se pueden expresar como archivos YAML, generalmente guardados dentro del propio proyecto para garantizar la coherencia en diferentes entornos.

[ Get the YAML cheat sheet. ]

Si bien los detalles del archivo de implementación varían según la aplicación, los siguientes son los archivos de implementación utilizados en esta aplicación de muestra:

apiVersion: apps/v1
kind: Deployment
metadata:
 labels:
   app: gin-app
 name: gin-app
spec:
 replicas: 2
 selector:
   matchLabels:
     app: gin-app
 template:
   metadata:
     labels:
       app: gin-app
   spec:
     containers:
       - image: quay.io/avulaj/web-service-gin
         imagePullPolicy: Always
         name: gin-app
         ports:
           - containerPort: 8080

Hay mucho aquí, así que dividiré las partes de este archivo:

• .metadata.labels Un conjunto de pares clave/valor que especifican las propiedades organizativas de un objeto.
• .metadata.name Indica el nombre de la implementación, aplicación de ginebra Bajo estas circunstancias.
• .spec.replicas Especifica cuántas copias de la aplicación están disponibles.
• .spec.selector Define cómo un ReplicaSet creado a partir de una implementación encuentra pods para administrar.
• template Defina las siguientes propiedades de PodSpec para el Pod creado:
  • .metadata.labels.app Especifica la etiqueta del pod.
  • .spec Definir un contenedor para el pod, aplicación de ginebraque se ejecutará quay.io/avulaj/web-service-ginque siempre extraerá la imagen especificada al iniciar un nuevo pod y expondrá el puerto 8080 en el host.

[ Get this complimentary eBook from Red Hat: Managing your Kubernetes clusters for dummies. ]

despliegue de aplicaciones

Ahora está listo para aplicar la implementación al clúster. Primero inicie sesión en su clúster a través de la CLI de OpenShift. Luego, crea un nuevo proyecto con el siguiente comando:

$ oc new-project 

presta atención a correr new-project También lo lleva al espacio de nombres recién creado.Por el bien de este tutorial, nombraré mi proyecto aplicación de ginebra.

A continuación, aplique la implementación al clúster:

$ oc apply -f 

Si esto funcionó, debería ver sus pods ejecutándose en el espacio de nombres que creó. Este es un resultado de muestra de la aplicación de la implementación de la sección anterior:

$ oc get pods
NAME                       READY   STATUS    RESTARTS   AGE
gin-app-76dc4f79b6-nxldg   1/1     Running   0          53s
gin-app-76dc4f79b6-x6jhb   1/1     Running   0          53s

crear servicio

Entonces, ahora la aplicación se ejecuta en un pod en el clúster, pero si no puede realizarle ninguna solicitud, tiene poco valor. Necesitas servicio.

Un objeto de servicio actúa como un equilibrador de carga para los pods que administra y crea entradas de DNS para que otros pods en el clúster accedan a él. Si bien puede usar un archivo YAML personalizado para crear su servicio (similar a cómo crea una implementación), puede usar OpenShift para crear un servicio para su ReplicaSet simplemente exponiendo la implementación:

$ oc expose deployment 

Si olvida el nombre de su implementación, puede recuperarlo con:

$ oc get deployment

Verifica que creaste el servicio:

$ oc get svc

Si desea ver más detalles sobre el servicio, eche un vistazo al YAML generado:

$ oc get svc  -oyaml
apiVersion: v1
kind: Service
metadata:
  creationTimestamp: "2022-11-30T21:04:51Z"
  labels:
    app: gin-app
  name: gin-app
  namespace: gin-app
  resourceVersion: "14092996"
  uid: 6f45b1a4-436e-45fc-99bd-239461b08880
spec:
  clusterIP: 172.30.19.7
  clusterIPs:
  - 172.30.19.7
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    app: gin-app
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}

crear ruta

Implementó su aplicación y creó un servicio para administrar el tráfico. Todo lo que queda es crear una ruta. El enrutamiento en OpenShift permite que las aplicaciones se alojen en URL públicas. Este ejemplo utiliza una ruta segura con cifrado predeterminado. En OpenShift CLI, ejecute:

$ oc create route edge --service=gin-app --insecure-policy=Redirect

• oc create es el comando básico.
• route sí subcomando create Se utiliza para exponer los contenedores externamente.
• edge sí subcomando route Declare que desea que la ruta use la terminación TLS perimetral.
• --service Especifica el servicio al que exponer las rutas.
• --insecure-policy Especifica cómo manejar el tráfico inseguro. Esto no es obligatorio, pero para fines de demostración, redirige el tráfico HTTP a HTTPS.

Verifica la creación de la ruta:

$ oc get routes -o yaml 

Después de crear las rutas, finalmente puede probar la API. El comando anterior debería mostrar su URL pública .spec.hostsin embargo, también puedes obtenerlo de forma más directa con:

$ oc get route  -ojson | jq -r '.spec.host'

entonces tú también puedes curl esta URL y ver la respuesta de la API:

$ curl -L gin-app-gin-app.apps.avulaj-test.0f83.s1.devshift.org/albums
[
    {
        "id": "1",
        "title": "Blue Train",
        "artist": "John Coltrane",
        "price": 56.99
    },
    {
        "id": "2",
        "title": "Jeru",
        "artist": "Gerry Mulligan",
        "price": 17.99
    },
    {
        "id": "3",
        "title": "Sarah Vaughan and Clifford Brown",
        "artist": "Sarah Vaughan",
        "price": 39.99
    }
]

envolver

Este tutorial crea una aplicación desde cero, la implementa en un clúster de OpenShift y la expone mediante HTTP. Desde la creación de contenedores de su aplicación hasta la implementación de la construcción y, finalmente, la exposición del servicio a través del enrutamiento, OpenShift proporciona un proceso sencillo para exponer sus servicios web.

Todo el código de esta guía se puede encontrar en mi repositorio GitHub.

[ Complimentary eBook: Podman in Action ]