Crea un conector personalizado y una conexión

En esta página, se describe cómo crear una especificación de OpenAPI para un servicio web y, luego, crear un conector personalizado y una conexión para este conector.

Antes de crear un conector personalizado, debes crear una especificación de OpenAPI para el servicio web.

Crea una especificación de OpenAPI para el servicio web

Los conectores personalizados admiten OpenAPI 3.0. También puedes crear la especificación de forma manual. Para obtener información sobre las especificaciones de OpenAPI, consulta Especificaciones de OpenAPI.

También puedes generar automáticamente la especificación de OpenAPI 2.0 con el middleware de Swagger de Gin. Para obtener más información, consulta Gin Swagger. Debes convertir la especificación de OpenAPI 2.0 a la especificación de OpenAPI v3.0 con Swagger Converter.

Es una muestra de la especificación de OpenAPI.

{
  "openapi": "3.0.0",
  "info": {
    "title": "Go HTTPbin Proxy Service",
    "description": "A simple Go service that proxies requests to httpbin.org, adding custom headers.",
    "version": "1.0.0"
  },
  "servers": [
    {
      "url": "http://localhost:8080"
    }
  ],
  "paths": {
    "/getData": {
      "get": {
        "summary": "Fetch data from httpbin.org/get",
        "description": "Sends a GET request to httpbin.org/get, including any custom headers.",
        "responses": {
          "200": {
            "description": "Successful response from httpbin.org",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        }
      }
    },
    "/postData/{id}": {
      "post": {
        "summary": "Post data to httpbin.org/post",
        "description": "Sends a POST request to httpbin.org/post with data, including any custom headers.",
        "parameters": [
          {
            "in": "path",
            "name": "id",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string"   

                  },
                  "address": {
                    "type": "string"
                  },
                  "gender": {
                    "type": "string"   
                  }
                },
                "required": [
                  "name",
                  "address",
                  "gender"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful response from httpbin.org",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - Invalid request body"
          }
        }
      }
    }
  }
}

Crea un conector personalizado y valida el servicio

Debes crear un conector personalizado y, luego, validar el servicio web usándolo en una conexión en Application Integration.

Antes de comenzar

Configura Private Service Connect (PSC) para esta máquina virtual y, luego, crea una vinculación de extremo.

Crea un conector personalizado

  1. En la consola, ve a la página Integration Connectors > Custom connectors y, luego, selecciona o crea un proyecto Google Cloud .

    Ir a la página Conectores personalizados

  2. Haz clic en Crear nuevo para abrir la página Crear conector personalizado.
  3. En la sección Detalles del conector, especifica los campos obligatorios, como Nombre del conector y Nombre visible.Además, ingresa los casos de uso del conector en el campo Descripción.
  4. Configurar el destino del conector para el acceso al backend: Habilita esta opción. Se mostrarán las secciones de configuración adicionales en la página.
  5. Cuenta de servicio: Selecciona una cuenta de servicio que tenga los roles necesarios.
  6. Logotipo: Sube una imagen a un bucket de Cloud Storage para usarla como logotipo del conector.
  7. En la sección Connector Specification, ingresa la URL pública de tu especificación de Open API o sube el archivo de especificación a un bucket de Cloud Storage.
  8. En la sección Destino del conector, agrega la dirección IP del adjunto del extremo y el puerto en el que se ejecuta el servicio.
  9. En la sección Autenticación del conector, selecciona Sin autenticación. Los tipos de autenticación no son compatibles con los conectores de Marketplace.
  10. En la sección Backend Variables, agrega las variables que deseas tomar como entrada mientras creas la conexión. Estas variables aparecen en la página de creación de la conexión y se envían en cada llamada a la API que se realiza al servicio. En esta sección, se deben agregar los valores que no cambiarán con las APIs, como las credenciales de backend de terceros.
  11. Crea el conector personalizado. Asegúrate de haber especificado un logotipo y de haber descrito los casos de uso del conector personalizado.

Crear una conexión

Después de crear el conector personalizado, crea la conexión para este conector.

  1. En la consola de Cloud, ve a la página Conectores de Integration > Conexiones y, luego, selecciona o crea un proyecto de Google Cloud.

    Ir a la página Conexiones

  2. Haz clic en Crear nuevo para abrir la página Crear conexión.
  3. Selecciona el conector personalizado que creaste.
  4. Agrega valores para los campos de conexión que definiste.
  5. Crea la conexión.

Valida el servicio

Para validar el servicio, crea una integración nueva.

  1. En la consola de Google Cloud, ve a la página Application Integration y, luego, crea una integración.
  2. Agrega el activador de API y la tarea del conector.
  3. Configura la tarea del conector para usar la conexión creada en el paso anterior. Agrega Data Mapper si es necesario.
  4. Configura el connectorInputPayload para el conector según el esquema.
  5. Ejecuta la integración para verificar que la conexión funcione.

Si la integración se ejecuta correctamente y devuelve la respuesta esperada, se valida el servicio web.

¿Qué sigue?