Aprovisiona una organización pagada con la línea de comandos

Estás viendo la documentación de Apigee X.
Consulta la documentación de Apigee Edge.

En esta sección, se describe cómo instalar y configurar Apigee desde la línea de comandos si usas una cuenta de pago. Consulta también Opciones de aprovisionamiento.

Paso 1: Definir las variables de entorno

Para definir variables de entorno en la línea de comandos:

  1. Accede a Cloud mediante el siguiente comando:
    gcloud auth login

    El comando abre una ventana del navegador y te solicita que elijas una cuenta (si tienes más de una). Cloud te solicita que permitas el acceso. Solo tienes que hacerlo una vez: no tendrás que ejecutar este comando, elegir una cuenta ni permitir el acceso en el futuro.

  2. Inicializa el SDK de Cloud, como se describe en Inicializa el SDK de Cloud; por ejemplo:
    gcloud init

    Durante la inicialización del SDK, ingresa o selecciona el ID del proyecto que creaste en los Requisitos. Configura este proyecto como el predeterminado. No es necesario que ejecutes este comando en el futuro, a menos que desees cambiar las configuraciones predeterminadas.

    Es posible que se te solicite que elijas la configuración. Si aprovisionas una instalación de Apigee nueva (lo que se supone en estos pasos), elige [2] Create a new configuration.

    Cuando ejecutes gcloud init, se te solicitará lo siguiente:

    • Un nombre de configuración. Debe comenzar con una letra en minúscula y puede contener una combinación de letras minúsculas, números y guiones. Deberás hacer referencia a este nombre si deseas cambiar los valores predeterminados para esta configuración de nube en el futuro.
    • El usuario que establece esta configuración. Por lo general, serás tú, pero puede ser otro usuario o una cuenta de servicio de nube que tenga permisos para administrar parámetros de configuración de la nube.
    • El ID del proyecto de Cloud en el que ejecutarás Apigee. Este es el proyecto que creaste en los requisitos previos.
    • La región y zona predeterminadas de Compute y la zona para tu proyecto. Puedes omitir este paso.
  3. Define las siguientes variables de entorno para el proyecto actual:
    AUTH="Authorization: Bearer $(gcloud auth print-access-token)"
    PROJECT_ID="YOUR_PROJECT_ID"
    PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
    RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
    ANALYTICS_REGION="YOUR_ANALYTICS_REGION"

    Aquí:

    • AUTH define el encabezado Authentication con un token del portador. Usarás este encabezado cuando llames a las API de Apigee.
    • PROJECT_ID es el ID del proyecto de Cloud que creaste como parte de los requisitos. Si no estás seguro de cuál es tu ID del proyecto, usa Cloud Console o el comando gcloud projects list para encontrarlo.
    • PROJECT_NUMBER es el número de proyecto de Cloud que creaste como parte de los requisitos. En este ejemplo, se emite un comando gcloud para obtener el número del proyecto. Como alternativa, puedes usar el comando gcloud projects list para encontrarlo.
    • RUNTIME_LOCATION es la ubicación física en la que se encuentra la instancia. Los valores válidos son cualquier región de Compute Engine. Para obtener más información, consulta Regiones y zonas disponibles.

    • ANALYTICS_REGION es la ubicación física en la que almacenas tus datos de estadísticas.

      En el que ANALYTICS_REGION es una de las siguientes opciones:

      asia-northeast1 asia-south1 australia-southeast1
      us-central1 us-east1 us-west1
      europe-west2 europe-west1

      Elige una región que esté geográficamente cerca o que cumpla con los requisitos de almacenamiento de tu organización.

      Tanto RUNTIME_LOCATION como ANALYTICS_REGION pueden ser de la misma región, pero no es necesario que sean iguales. Sin embargo, puede haber un beneficio de rendimiento si son iguales.

  4. (Opcional) Para verificar su trabajo, repita los valores que acaba de configurar. Ten en cuenta que cuando quieras usar una variable en tus comandos, deberás colocar un signo de dólar antes de su nombre ($).
    echo $AUTH
    echo $PROJECT_ID
    echo $PROJECT_NUMBER
    echo $RUNTIME_LOCATION
    echo $ANALYTICS_REGION
    

    Las respuestas a tus comandos echo deberían verse de la siguiente manera:

    Authorization: Bearer ya29.a123456678940B63hPSAMPLEsampleKKYVsample0f3pWDWZDuH2-hENkNa
    TvgZ1PD977TMvv6edBQPJezdHw040880Ol_LoD5ZDkt-i-knizia_KhA9L20sSvztL81-SAMPLE42ELPMASk2_
    1CxN
    my-cloud-project
    1234567890
    us-west1
    us-west1
    

Paso 2: Habilitar las API

Para habilitar las API requeridas en la línea de comandos, haz lo siguiente:

  1. Accede e inicializa tu proyecto de Cloud si todavía no lo hiciste.
  2. Ejecuta el comando services enable para habilitar las cuatro API obligatorias que se mencionaron anteriormente:

    gcloud services enable apigee.googleapis.com \
      servicenetworking.googleapis.com compute.googleapis.com \
      cloudkms.googleapis.com --project=$PROJECT_ID
  3. Si deseas verificar tu trabajo, usa el comando services list para mostrar todas las API habilitadas (opcional):

    gcloud services list

    En la respuesta, se muestran todos los servicios habilitados, incluidas las API que acabas de habilitar (Apigee, Service Networking, Cloud KMS y Compute Engine). En el siguiente ejemplo, se muestra una lista posible de las API que muestra este comando:

    ...                                    ...
    apigee.googleapis.com                  Apigee API
    appengineflex.googleapis.com           Google App Engine Flexible Environment
    ...                                    ...
    cloudkms.googleapis.com                Cloud Key Management Service (KMS) API
    compute.googleapis.com                 Compute Engine API
    ...                                    ...
    servicemanagement.googleapis.com       Service Management API
    servicenetworking.googleapis.com       Service Networking API
    ...                                            ...

    Si bien tu lista completa de API puede ser diferente de las que se muestran arriba, debe incluir las API que habilitaste en este paso. De lo contrario, intenta ejecutar el comando anterior para cada API (uno por vez) a fin de habilitarlos. Como alternativa, puedes usar Console para habilitar las API.

Paso 3: Crear el agente de servicio de Apigee

Para crear el agente de servicio de Apigee en la línea de comandos, sigue estos pasos:

  1. Ejecuta el comando services identity create:

    gcloud  beta services identity create --service=apigee.googleapis.com --project=$PROJECT_ID
  2. Verifica que el agente se haya creado correctamente. La respuesta debe mostrar el nombre del agente en el siguiente formato: service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. Por ejemplo:

    Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com

    Copia este nombre. La necesitarás en pasos posteriores.

Paso 4: Configurar las herramientas de redes de servicio

Para configurar las herramientas de redes de servicio en la línea de comandos, haz lo siguiente:

  1. Crea un rango de intercambio de tráfico con el siguiente comando:
    gcloud compute addresses create RANGE_NAME \
      --global \
      --prefix-length=PREFIX_LENGTH \
      --description="Peering range for Google services" \
      --network=NETWORK_NAME \
      --purpose=VPC_PEERING \
      --project=$PROJECT_ID

    Aquí:

    • RANGE_NAME es el nombre del rango de direcciones IP que estás creando. Puedes nombrar el rango como desees. Por ejemplo: google-svcs
    • --global especifica el alcance de las direcciones IP. Debes incluir esto en tu comando.
    • --prefix-length especifica el tamaño del bloque CIDR (la cantidad de direcciones IP permitidas en el rango). El valor de --prefix-length debe ser 16 o 20 para las organizaciones de pago.

      Para las organizaciones de pago, te recomendamos que configures el valor como 16, que separa 65,536 direcciones IP. Para obtener más información, consulta Rangos de intercambio de tráfico.

    • --description especifica la información legible sobre el servicio.
    • --network es el nombre del recurso de red en el que se deben reservar las direcciones.

      La red debe tener un bloque CIDR de las direcciones IP disponibles que sean al menos el tamaño de prefix-length.

      Google crea una red predeterminada (llamada default) para cada proyecto nuevo, por lo que puedes usarla. Sin embargo, no recomienda usar la red predeterminada para nada más que la prueba.

    • --purpose es el tipo de recurso de dirección. Configura el valor de purpose como VPC_PEERING.
    • --project es el ID del proyecto de Cloud, para el que puedes usar el valor de variable que definiste antes ($PROJECT_ID).

    Si se ejecuta de forma correcta, gcloud responde con lo siguiente:

    Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].

    Después de crear un rango de direcciones IP, las direcciones se asocian al proyecto hasta que las liberes.

  2. Conecta tus servicios a la VPC con el siguiente comando:
    gcloud services vpc-peerings connect \
      --service=servicenetworking.googleapis.com \
      --network=NETWORK_NAME \
      --ranges=RANGE_NAME \
      --project=$PROJECT_ID

    Aquí:

    • --network es el nombre del recurso de red que especificaste en el paso anterior. Por ejemplo: default
    • --ranges es el nombre del rango de direcciones IP que especificaste en el paso anterior.

    Esta operación puede tardar varios minutos en completarse.

    Si se ejecuta de forma correcta, gcloud responde con lo siguiente:

    Operation "operations/OPERATION_ID" finished successfully.

    En el que OPERATION_ID es el UUID de la LRO.

  3. Apigee crea una conexión entre tu VPC y los servicios de Google. Específicamente, Apigee conecta tu proyecto con la API de Service Networking a través del intercambio de tráfico de VPC. Apigee también asocia direcciones IP a tu proyecto.

Paso 5: Crear una organización

Antes de crear una organización, debes crear un llavero de claves y una clave de encriptación de la base de datos del entorno de ejecución. En esta sección, se describe cómo hacerlo y, luego, se envía una solicitud para crear la organización.

Para crear una organización nueva en la línea de comandos, haz lo siguiente:

  1. Crea un llavero de claves y una clave de encriptación de la base de datos del entorno de ejecución:

    1. Define una variable de entorno para la ubicación de la clave y el llavero de encriptación de la base de datos del entorno de ejecución. Esto garantiza la coherencia cuando se crean y facilita el seguimiento en la documentación.

      El valor es la ubicación física en la que se almacenan el llavero de claves y la clave de encriptación de la base de datos del entorno de ejecución.

      • Opciones de configuración de región única (en las que solo tienes una instancia en una región): elige entre las ubicaciones regionales de KMS compatibles.

        Por ejemplo:

        APPKEY_LOCATION="us-west1"

        El valor puede ser el mismo que la $RUNTIME_LOCATION (también una región), pero no es necesario que lo sea. Sin embargo, puede haber un beneficio de rendimiento si son iguales.

      • Opciones de configuración multirregional: Elige entre ubicaciones multirregionales compatibles (como us o eu) o ubicaciones birregionales.

        Por ejemplo:

        APPKEY_LOCATION="us"

        Google recomienda que, si tienes una configuración multirregional en EE.UU., debes usar us para tu ubicación, si es posible. De lo contrario, usa nam4.

    2. Crea un llavero de claves nuevo mediante el comando gcloud; por ejemplo:
      gcloud kms keyrings create my-app-key-ring --location $APPKEY_LOCATION --project $PROJECT_ID

      Esto crea un llavero de claves nuevo con el nombre my-app-key-ring. La ubicación de la clave de encriptación de la base de datos del entorno de ejecución de Apigee admite todas las ubicaciones de Cloud KMS compatibles con Cloud HSM y Cloud EKM.

      El nombre del llavero de claves debe ser único para tu organización. Si creas una segunda región o una posterior, el nombre no puede ser el mismo que los nombres de otros llaveros de claves.

    3. Crea una clave con el comando gcloud kms keys create; por ejemplo:
      gcloud kms keys create my-app-key --keyring my-app-key-ring \
        --location $APPKEY_LOCATION --purpose "encryption" --project $PROJECT_ID

      Este comando crea una clave llamada my-app-key y la agrega al llavero de claves.

      Se puede hacer referencia a la clave mediante su ID de clave. Puedes obtener el ID de clave con el siguiente comando:

      gcloud kms keys list \
        --location=$APPKEY_LOCATION \
        --keyring=$APPKEY_KEY_RING_NAME \
        --project=$PROJECT_ID

      El ID de clave tiene la siguiente sintaxis (similar a una ruta de archivo):

      projects/PROJECT_ID/locations/APPKEY_LOCATION/keyRings/APPKEY_RING_NAME/cryptoKeys/APPKEY_NAME

      En este ejemplo, el ID de clave es la siguiente:

      projects/my-cloud-project/locations/us-west1/keyRings/my-app-key-ring/cryptoKeys/my-app-key
    4. Otorga acceso para que el agente de servicio de Apigee use la clave nueva mediante la ejecución del comando de gcloud kms keys add-iam-policy-binding con la siguiente sintaxis:

      gcloud kms keys add-iam-policy-binding APP_KEY_NAME \
        --location APP_KEY_LOCATION \
        --keyring APP_KEY_RING_NAME \
        --member serviceAccount:service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project PROJECT_ID

      Por ejemplo:

      gcloud kms keys add-iam-policy-binding my-app-key \
        --location $APPKEY_LOCATION \
        --keyring my-app-key-ring \
        --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project $PROJECT_ID

      Este comando vincula la clave con el agente de servicio de Apigee.

      Cuando se completa correctamente esta solicitud, gcloud muestra una respuesta similar a la siguiente:

      Updated IAM policy for key [runtime].
      bindings:
      - members:
        - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
        role: roles/cloudkms.cryptoKeyEncrypterDecrypter
      etag: BwWqgEuCuwk=
      version: 1

      Si recibes un error como el que se muestra a continuación, haz lo siguiente:

      INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

      Asegúrate de haber usado el número del proyecto, y no el nombre, en la dirección de correo electrónico de la cuenta de servicio.

    Para obtener más información, consulta Acerca de las claves de encriptación de Apigee.

  2. Para crear la organización, envía la siguiente solicitud a la API de la organización:

    curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
      -H "$AUTH" \
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name":"'"$PROJECT_ID"'",
        "analyticsRegion":"'"$ANALYTICS_REGION"'",
        "runtimeType":"CLOUD",
        "authorizedNetwork":"NETWORK_NAME",
        "runtimeDatabaseEncryptionKeyName":"DATABASE_KEY_NAME"
      }'

    Aquí:

    • $AUTH inserta el encabezado Authorization que creaste y colocaste en la variable $AUTH en el paso Define variables de entorno.

    • -X POST le indica a curl que envíe tu solicitud como un POST HTTP.
    • -H inserta encabezados HTTP en la solicitud. En este caso, debes incluir los encabezados Authorization y Content-Type.
    • -d define la carga útil de datos para la solicitud. Esta carga útil debe incluir lo siguiente:
      • name: Identifica tu organización nueva. Debe ser el mismo que el ID del proyecto. $PROJECT_ID: Inserta el valor de la variable de entorno PROJECT_ID.

        Ten en cuenta que este comando y los comandos posteriores de esta sección usan las variables de entorno predefinidas que creaste en el Definir variables de entorno.

      • analyticsRegion: Especifica la ubicación física en la que se almacenarán tus datos de estadísticas.

        En el ejemplo anterior, analyticsRegion es una de las siguientes opciones:

        asia-northeast1 asia-south1 australia-southeast1
        us-central1 us-east1 us-west1
        europe-west2 europe-west1

        Elige una región que esté geográficamente cerca o que cumpla con los requisitos de almacenamiento de tu organización.

      • runtimeType: Configura este valor en CLOUD.
      • authorizedNetwork: Identifica la red de intercambio de tráfico que especificaste en Configura las herramientas de redes de servicios.
      • runtimeDatabaseEncryptionKeyName: El nombre de la clave de encriptación de la aplicación que creaste en el paso anterior.

    Después de ejecutar este comando, Apigee inicia una operación de larga duración, que puede tardar de tres a cuatro minutos en completarse. Si Apigee muestra una respuesta de inmediato, es probable que tu proyecto aún no se haya aprovisionado. En este caso, comunícate con Ventas de Apigee.

    Si recibes un error, verifica el uso de comillas alrededor de los valores de las variables en la carga útil de datos. Asegúrate de tener comillas dobles alrededor de la variable $PROJECT_ID, como se muestra en el siguiente ejemplo:

    "'"$PROJECT_ID"'"

    Si usas una string para el ID del proyecto, puedes encerrarla entre comillas dobles dentro de la string de la carga útil que se encuentra entre comillas simples, como se muestra en el siguiente ejemplo:

    '{ "name":"my-gcp-project", ... }'
  3. Espera entre tres y cuatro minutos.
  4. Para verificar el estado de la solicitud de creación, envía una solicitud GET a la API de la lista de organizaciones, como se muestra en el siguiente ejemplo:
    curl -H "$AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

    Si Apigee creó una organización nueva de forma correcta, recibirás una respuesta similar a la que se muestra a continuación:

    {
      "name": "my-cloud-project",
      "createdAt": "1592586495539",
      "lastModifiedAt": "1592586495539",
      "environments": [],
      "properties": {
        "property": [
          {
            "name": "features.hybrid.enabled",
            "value": "true"
          },
          {
            "name": "features.mart.connect.enabled",
            "value": "true"
          }
        ]
      },
      "analyticsRegion": "us-west1",
      "runtimeType": "CLOUD",
      "subscriptionType": "PAID",
      "caCertificate": "CERTIFICATE",
      "authorizedNetwork": "my-network",
      "projectId": "my-cloud-project"
    }

    Si Apigee muestra una respuesta de error HTTP, consulta Crea una organización de Apigee.

Paso 6: Crear una instancia del entorno de ejecución

Para crear una instancia nueva de un entorno de ejecución en la línea de comandos, haz lo siguiente:

  1. Verifica que Apigee haya terminado de crear tu organización. Enviaste una solicitud para crear una organización nueva en Crea una organización de Apigee, pero debes asegurarte de que esté completado antes de continuar.

    Para hacerlo, envía la siguiente solicitud a la API de las organizaciones:

    curl -i -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

    Si la organización existe (y tienes los permisos adecuados para verla), Apigee responderá con sus detalles. Si Apigee responde con un error, espera unos minutos y vuelve a enviar la solicitud.

  2. Crea una clave de encriptación del disco:
    1. Crea un llavero de claves de disco nuevo con el comando de gcloud:
      gcloud kms keyrings create my-disk-key-ring \
        --location $RUNTIME_LOCATION \
        --project $PROJECT_ID

      Esto crea un llavero de claves nuevo con el nombre my-disk-key-ring. El llavero de claves del disco debe estar configurado en la misma ubicación que la instancia. Cada instancia y llavero de claves deben tener su propia ubicación.

    2. Crea una clave de disco nueva con el comando kms keys create; por ejemplo:
      gcloud kms keys create my-disk-key --keyring my-disk-key-ring \
        --location $RUNTIME_LOCATION --purpose "encryption" --project $PROJECT_ID

      En este ejemplo, se crea una clave nueva llamada my-disk-key y la agrega al llavero de claves my-disk-key-ring.

      Se puede hacer referencia a la clave por la ruta de acceso de la clave. Puedes obtener la ruta de acceso de la clave con el siguiente comando:

      gcloud kms keys list \
        --location=$RUNTIME_LOCATION \
        --keyring=$DISK_KEY_RING_NAME \
        --project=$PROJECT_ID

      La ruta de acceso de la clave se ve de la siguiente manera:

      projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
    3. Otorga acceso para que el agente de servicio de Apigee use la clave nueva mediante la ejecución del comando gcloud kms keys add-iam-policy-binding; por ejemplo:
      gcloud kms keys add-iam-policy-binding my-disk-key \
        --location $RUNTIME_LOCATION \
        --keyring my-disk-key-ring \
        --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project $PROJECT_ID

      Este comando vincula la clave con el agente de servicio de Apigee.

    Para obtener más información, consulta Acerca de las claves de encriptación de Apigee.

  3. Crea una instancia de entorno de ejecución nueva para tu proyecto mediante el envío de una solicitud POST a la API de instancias; por ejemplo:
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
      -X POST -H "$AUTH" \
      -H "Content-Type:application/json" \
      -d '{
        "name":"INSTANCE_NAME",
        "location":"$RUNTIME_LOCATION",
        "diskEncryptionKeyName":"KEY_ID",
        "peeringCidrRange":"[SLASH_16|SLASH_20]"
      }'

    Aquí:

    • -X POST configura el tipo de solicitud como POST HTTP.
    • -H "$AUTH" inserta el valor de la variable de entorno AUTH para el encabezado Authorization.
    • -H "Content-Type:application/json" inserta un encabezado que le indica a curl que envíe tu carga útil de datos con el formato JSON.
    • -d define la carga útil de la solicitud. Debe contener lo siguiente:
      • name: El nombre de tu instancia nueva. Por ejemplo, my-runtime-instance. El nombre debe comenzar con una letra en minúscula, puede tener hasta 32 caracteres y solo puede incluir letras en minúscula, números y guiones. No puede comenzar ni terminar con un guion y debe tener al menos dos caracteres.
      • location es el lugar físico en el que se aloja tu clúster. Los valores válidos son cualquier ubicación permitida por Compute Engine. (Consulta Regiones y zonas disponibles). En este ejemplo, se usa us-west1.
      • diskEncryptionKeyName, en el que KEY_ID es el ID de la clave de encriptación del disco que creaste en el paso anterior.
      • peeringCidrRange (opcional): El tamaño del rango de direcciones IP de CIDR que usa Compute para asignar recursos en tu VPC. Los valores válidos son SLASH_16 y SLASH_20.

        Este valor debe coincidir con el tamaño de rango que estableces con la opción --prefix-length en Configurar red de servicios. Por ejemplo, si configuras --prefix-length en 16, establece peeringCidrRange como SLASH_16.

        El valor predeterminado es SLASH_16.

    Esta solicitud puede tardar hasta 20 minutos en completarse porque Apigee debe crear e iniciar un clúster nuevo de Kubernetes, instalar los recursos de Apigee en ese clúster y configurar el balanceo de cargas.

    Tras una solicitud exitosa, Apigee responde de forma inicial para informarte que la creación se encuentra en curso. La respuesta se verá de la siguiente manera:

    {
      "instances": [
        {
          "name": "my-project",
          "location": "us-west1",
          "diskEncryptionKeyName": "your-disk-key-name",
          "state": "CREATING",
          "peeringCidrRange": "SLASH_16"
        }
      ]
    }

    Si Apigee muestra un error, consulta Crea una instancia nueva.

  4. Espera alrededor de 20 minutos.
  5. Para verificar el estado de tu solicitud de creación de instancias del entorno de ejecución, puedes realizar una de las siguientes acciones:
    • Usa la API de las operaciones para obtener el estado de la operación (preferida). Se prefiere esta acción porque no muestra un error si la operación está en curso. Sin embargo, la siguiente llamada a la API muestra un error en algunas circunstancias.
    • Obtén una lista de instancias existentes del entorno de ejecución mediante el envío de una solicitud GET a la API de las instancias:
      curl -i -X GET -H "$AUTH" \
        "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

      Si hay instancias del entorno de ejecución disponibles asociadas con tu cuenta de Cloud, Apigee responde a la solicitud con detalles sobre cada una, que se ven de la siguiente manera:

      {
        "instances": [
          {
            "name": "my-runtime-instance",
            "location": "us-west1",
            "host": "10.16.0.2",
            "port": "443"
          },
          ...
        ]
      }

      Aquí:

      • name y location son los valores que especificaste en la solicitud inicial para crear una instancia.
      • host es la dirección IP interna del balanceador de cargas del clúster. Apigee se conectará a esta cuando entregue las solicitudes del entorno de ejecución de la API.
      • port es el puerto del balanceador de cargas en el que se conecta Apigee.

      Si no hay instancias disponibles del entorno de ejecución (y Apigee aún no creó una nueva), Apigee responde con un error.

Para obtener más detalles sobre cómo crear una instancia del entorno de ejecución, incluida información adicional de contexto y solución de problemas, consulta el Paso 6: Crea una instancia del entorno de ejecución.

Paso 7: Crear un entorno

Para crear un entorno y adjuntarlo al entorno de ejecución en la línea de comandos, haz lo siguiente:

  1. Crea un entorno nuevo con la API de los entornos mediante el uso del siguiente comando:
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
      -H "$AUTH" \
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name":"ENVIRONMENT_NAME"
      }'

    En el ejemplo anterior, -d contiene la carga útil de datos que define el nombre de tu entorno nuevo.

    Apigee crea el entorno nuevo. Esta operación puede tardar varios minutos en completarse.

  2. Antes de continuar, verifica que Apigee haya terminado de crear el entorno nuevo mediante el envío de una solicitud GET a la API de los entornos:
    curl -i -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

    Apigee responde con una lista de los entornos disponibles. Por ejemplo, si el nombre de tu entorno es una prueba, Apigee responde con lo siguiente:

    [
      "test"
    ]
  3. Adjunta el entorno nuevo a la instancia del entorno de ejecución, como se muestra en el siguiente ejemplo:
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instancis/INSTANCE_NAME/attachments" \
        -X POST -H "$AUTH" \
        -H "content-type:application/json" \
        -d '{
          "environment":"ENVIRONMENT_NAME"
        }'

    Al igual que con el comando anterior, mediante este comando también se activa una operación de larga duración. Comprueba que el entorno se haya adjuntado al entorno de ejecución antes de continuar. Si es así, deberías obtener un error 409, como se muestra en el siguiente ejemplo:

    {
      "error": {
        "code": 409,
        "message": "the attachment '61a36502-4242-4e6d-4242-0ab2e22c0ffc' already exists for instance
          'us-west1' and environment 'ENVIRONMENT_NAME'",
        "status": "ALREADY_EXISTS"
      }
    }

    Solo después de asegurarte de que el entorno nuevo se haya creado y adjuntado al entorno de ejecución, puedes crear un grupo de entornos nuevo.

  4. Crea un grupo de entornos nuevo con el siguiente comando:
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
      -H "$AUTH" \
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name": "ENV_GROUP_NAME",
        "hostnames":["ENV_GROUP_HOST"]
      }'

    Por ejemplo:

    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
      -H "$AUTH"\
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name": "test-group",
        "hostnames":["sales.example.com"]
      }'
  5. Espera a que se complete la operación. Puedes verificar el estado de tu grupo nuevo mediante una solicitud como la siguiente:
    curl -i -H "$AUTH" -H "Content-Type:application/json" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/ENVIRONMENT_NAME"
  6. Conecta el entorno nuevo al grupo de entornos nuevo con el siguiente comando:
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/ENV_GROUP_NAME/attachments" \
      -X POST \
      -H "$AUTH" \
      -H "content-type:application/json" \
      -d '{
        "environment":"ENVIRONMENT_NAME"
      }'

    Por ejemplo:

    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/test-group/attachments" \
      -X POST -H "$AUTH" \
      -H "content-type:application/json" \
      -d '{
        "environment":"ENVIRONMENT_NAME"
      }'

    Esto activa una operación de larga duración que puede tardar varios minutos en completarse. Te recomendamos que esperes uno o dos minutos antes de continuar con el siguiente paso. Mientras tanto, puedes verificar el estado de la operación como antes.

  7. Envía una solicitud PATCH para actualizar el alias del host, como se muestra en el siguiente ejemplo (opcional):
    curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/test-group?updateMask=hostnames" \
      -X PATCH -H "$AUTH" \
      -H "content-type:application/merge-patch+json" \
      -d '{
        "hostnames":["test-group-new.sandbox.apigeeks.net"]
      }'

    Esto activa una operación de larga duración que puede tardar varios minutos en completarse. Te recomendamos que esperes uno o dos minutos antes de continuar con el siguiente paso. Mientras tanto, puedes verificar el estado de la operación como antes.

Para obtener más detalles sobre la creación de entornos de Apigee, incluida información adicional de contexto y solución de problemas, consulta el Paso 7: Crea un entorno.

Paso 8: Configurar el enrutamiento

Decide si deseas permitir el acceso externo o solo el acceso interno:

Tipo de acceso Descripción de los procesos de configuración e implementación
Interna (recomendado)

Permite solo el acceso interno a tu API.

Descarga el proxy de Hello World desde GitHub y, luego, impleméntalo en la instancia del entorno de ejecución. Luego, debes crear una VM nueva dentro de la red y conectarte a ella. Desde la VM nueva, puedes enviar una solicitud al proxy de la API.

Externo

Permite el acceso externo a tu API.

Descarga el proxy de Hello World desde GitHub y, luego, impleméntalo en la instancia del entorno de ejecución. Luego, puedes enviar una solicitud al proxy de API desde tu máquina de administrador o desde cualquier máquina habilitada para la red.

Dada la complejidad de este proceso, Apigee recomienda que solo los usuarios avanzados lo lleven a cabo.

Cada uno de estos enfoques se presenta en una pestaña en las instrucciones que aparecen a continuación.

Interna

No hay tareas que realizar en este paso si usas la línea de comandos a fin de configurar un proxy de API solo para el acceso interno. Puedes ir directamente al Paso 8: Implementa un proxy de muestra, en el que enviarás una solicitud al proxy de API.

Externo

En esta sección, se describe cómo configurar el enrutamiento cuando usas la línea de comandos y quieres permitir el acceso externo al proxy de tu API. Debes hacer esto para poder enviar una solicitud desde un cliente externo hacia la instancia del entorno de ejecución de Apigee.

El proceso general es el siguiente:

Paso 8a: Habilitar el Acceso privado a Google para la subred
Paso 8b: Configurar las variables de entorno
Paso 8c: Crear un grupo de instancias administrado
Paso 8d: Obtener direcciones IP y crear reglas de firewall
Paso 8e: Subir credenciales
Paso 8f: Crear un balanceador de cargas global

Cada uno de estos pasos se describe en las siguientes secciones.

Paso 8a: Habilita el Acceso privado a Google para la subred

Si quieres habilitar el Acceso privado a Google para la subred, sigue los pasos que se indican en Habilita el acceso privado a Google.

Paso 8b: Configura variables de entorno

En las instrucciones de esta sección, se usan variables de entorno para hacer referencia a strings que se usan de forma repetida. Te recomendamos que las configures antes de continuar.

Para configurar las variables de entorno, ejecuta los siguientes comandos:

MIG_NAME=apigee-mig-us-west1
VPC_NAME=default       # If you are using a shared VPC, use the shared VPC name
VPC_SUBNET=default     # Private Google Access must be enabled for this subnet
REGION=us-west1        # The same region as your Apigee runtime instance
APIGEE_ENDPOINT=APIGEE_INSTANCE_IP     # See the tip below for details on getting this IP address value

Deberá usar estas variables muchas veces durante los procesos restantes. Si deseas configurar varias regiones, crea variables con valores específicos para cada región.

Paso 8c: Crea un grupo de instancias administrado

En este paso, crearás y configurarás un grupo de instancias administrado (MIG). En un paso posterior, agregará el MIG a un servicio de backend que está conectado a un balanceador de cargas global. Se requiere un MIG para enviar tráfico de API desde el servicio de backend del balanceador de cargas global a Apigee.

Para crear un MIG, sigue estos pasos:

  1. Crea una plantilla de instancias mediante la ejecución del siguiente comando.
    gcloud compute instance-templates create $MIG_NAME \
      --project $PROJECT_ID \
      --region $REGION \
      --network $VPC_NAME \
      --subnet $VPC_SUBNET \
      --tags=https-server,apigee-mig-proxy,gke-apigee-proxy \
      --machine-type e2-medium --image-family debian-10 \
      --image-project debian-cloud --boot-disk-size 20GB \
      --metadata ENDPOINT=$APIGEE_ENDPOINT,startup-script-url=gs://apigee-5g-saas/apigee-envoy-proxy-release/latest/conf/startup-script.sh

    Como se puede ver en este comando, las máquinas son del tipo e2-medium. Ejecutan Debian 10 y tienen 20 GB de disco. La secuencia de comandos startup-script.sh configura el MIG para enrutar el tráfico entrante desde el balanceador de cargas hasta la instancia de Apigee.

  2. Para crear un grupo de instancias administrado, ejecuta el siguiente comando:
    gcloud compute instance-groups managed create $MIG_NAME \
      --project $PROJECT_ID --base-instance-name apigee-mig \
      --size 2 --template $MIG_NAME --region $REGION
  3. Configura el ajuste de escala automático para el grupo mediante la ejecución del comando siguiente:
    gcloud compute instance-groups managed set-autoscaling $MIG_NAME \
      --project $PROJECT_ID --region $REGION --max-num-replicas 20 \
      --target-cpu-utilization 0.75 --cool-down-period 90
  4. Define un puerto con nombre mediante la ejecución del siguiente comando:
    gcloud compute instance-groups managed set-named-ports $MIG_NAME \
      --project $PROJECT_ID --region $REGION --named-ports https:443

Paso 8d: Obtén direcciones IP y crea reglas de firewall

Debes asignar una dirección IP al balanceador de cargas y, luego, crear reglas que permitan al balanceador de cargas acceder al MIG.

Para obtener las direcciones IP del balanceador de cargas y crear las reglas de firewall, sigue estos pasos:

  1. Reserva una dirección IP para el balanceador de cargas:
    gcloud compute addresses create lb-ipv4-vip-1 \
      --project $PROJECT_ID \
      --ip-version=IPV4 \
      --global
  2. Obtén una dirección IP reservada mediante la ejecución del siguiente comando:
    gcloud compute addresses describe lb-ipv4-vip-1 \
      --project $PROJECT_ID --format="get(address)" --global
  3. Crea una regla de firewall que permita al balanceador de cargas acceder al MIG con el siguiente comando:
    gcloud compute firewall-rules create k8s-allow-lb-to-apigee-mig \
      --description "Allow incoming from GLB on TCP port 443 to Apigee Proxy" \
      --project $PROJECT_ID --network $VPC_NAME --allow=tcp:443 \
      --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gke-apigee-proxy

    Ten en cuenta que los rangos de direcciones IP 130.211.0.0/22 y 35.191.0.0/16 son los rangos de direcciones IP de origen para el balanceo de cargas de Google. Esta regla de firewall permite a Google Cloud Load Balancing realizar solicitudes de verificación de estado al MIG.

Paso 8e: Sube credenciales

Para subir tus credenciales a Cloud, haz lo siguiente:

  1. Genera un certificado y una clave. Puedes usar un certificado autofirmado u obtener un certificado de una autoridad certificadora. No recomendamos el uso de certificados autofirmados en un entorno de producción. Si lo deseas, puedes instalar varios certificados en el balanceador de cargas. Para obtener más información sobre el uso de certificados SSL con el balanceador de cargas de Google, consulta Certificados SSL y Descripción general del certificado SSL.
  2. Sube el certificado y la clave del servidor SSL a Google Cloud mediante el comando gcloud compute ssl-certificates create:
    gcloud compute ssl-certificates create apigee-ssl-cert \
      --project $PROJECT_ID --certificate=/PATH_TO_TLS_CERTIFICATE \
      --private-key=/PATH_TO_TLS_KEY

Paso 8f: Crea un balanceador de cargas global

Para crear un balanceador de cargas global, haz lo siguiente:

    gcloud compute health-checks create https hc-apigee-mig-443 \
      --project $PROJECT_ID --port 443 --global \
      --request-path /healthz/ingress

    Usarás esta verificación de estado para garantizar que el servicio de backend se esté ejecutando. Para configurar verificaciones de estado más avanzadas en un proxy específico, consulta Realiza verificaciones de estado.

  1. Crea un servicio de backend llamado apigee-mig-backend con el siguiente comando:
    gcloud compute backend-services create apigee-mig-backend \
      --project $PROJECT_ID --protocol HTTPS --health-checks hc-apigee-mig-443 \
      --port-name https --timeout 60s --connection-draining-timeout 300s --global
  2. Agrega el MIG al servicio de backend con el siguiente comando:
    gcloud compute backend-services add-backend apigee-mig-backend \
      --project $PROJECT_ID --instance-group $MIG_NAME \
      --instance-group-region $REGION \
      --balancing-mode UTILIZATION --max-utilization 0.8 --global
  3. Crea un mapa de URL de balanceo de cargas mediante el comando siguiente:
    gcloud compute url-maps create apigee-mig-proxy-map \
      --project $PROJECT_ID --default-service apigee-mig-backend
  4. Crea un proxy HTTPS de destino de balanceo de cargas mediante el siguiente comando:
    gcloud compute target-https-proxies create apigee-mig-https-proxy \
      --project $PROJECT_ID --url-map apigee-mig-proxy-map \
      --ssl-certificates apigee-ssl-cert
  5. Crea una regla de reenvío global mediante el siguiente comando:
    gcloud compute forwarding-rules create apigee-mig-https-lb-rule \
      --project $PROJECT_ID --address lb-ipv4-vip-1 --global \
      --target-https-proxy apigee-mig-https-proxy --ports 443

¡Listo! Ya estás listo para llamar al proxy de API.

Para obtener detalles sobre la configuración del enrutamiento, además de información adicional sobre el contexto y la solución de problemas, consulta el Paso 8: Configura el enrutamiento de acceso.

Paso 9: Implementar un proxy de muestra

Para implementar el proxy de ejemplo mediante la línea de comandos, haz lo siguiente:

  1. Descarga el proxy de muestra de Hello World desde GitHub.

    Un proxy de API con este formato se conoce como un paquete de proxy.

  2. Sube el paquete del proxy de API al entorno de ejecución mediante la API de los proxies de API, como se muestra en el siguiente ejemplo:
    curl -i -X POST -H "$AUTH" \
      -H "Content-Type:multipart/form-data" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=PROXY_BASE_PATH&action=import" \
      -F 'file=@/PATH/TO/FILE/httpbin_rev1_2020_02_02.zip'
  3. Implementa el proxy de API en el entorno test como se muestra en el siguiente ejemplo:
    curl -i -H "$AUTH" -X POST \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/ENVIRONMENT_NAME/apis/PROXY_BASE_PATH/revisions/1/deployments"

    Puedes usar $PROXY_BASEPATH para PROXY_BASE_PATH.

  4. Si permitiste el acceso externo al proxy de API, haz lo siguiente:

    Envía una solicitud al proxy de API desde cualquier máquina habilitada para la red mediante la ejecución del siguiente comando:

    curl -i -H "Host: test-group-new.sandbox.apigeeks.net" \
      https://PUBLIC_LOAD_BALANCER_IP/httpbin

    De manera opcional, agrega la opción -k para omitir la autenticación en una situación de prueba como esta.

    Puedes encontrar la dirección IP del balanceador de cargas pública de la siguiente manera: en Cloud Console, navega hasta Servicios de red > Balanceo de cargas. Haz clic en el nombre del balanceador de cargas para ver la página de detalles del balanceador de cargas. La dirección IP aparece en la lista.

  5. Si otorgaste acceso interno solo al proxy de API, consulta Llama a un proxy de API con acceso solo interno.

Para obtener más información sobre la implementación de proxies, además de información adicional de solución de problemas, consulta el Paso 9: Implementa un proxy de muestra.