En esta página, se muestra cómo entregar una API desde un dominio personalizado de tu propiedad, por ejemplo, example.com.
Como alternativa a usar tu propio nombre de dominio, puedes usar un nombre de dominio que administra Google. Consulta Utilizar un dominio administrado por Google para obtener más información.
Antes de comenzar
Obtén un nombre de dominio desde un registro de nombres de domino si todavía no tienes uno para usar con tu API.
La forma recomendada de entregar una API desde instancias de Compute Engine es usar un balanceador de cargas en un grupo de instancias. Debes reservar una dirección IP externa para el nombre de dominio y usarla con el balanceador de cargas.
Para entregar la API desde un nombre de dominio, haz lo siguiente:
Reserva una dirección IP externa estática como mínimo en tu proyecto:
Asígnale el nombre que desees a la dirección IP reservada.
Para Tipo, haz clic en Global.
En Adjunto a, haz clic en Ninguno. Adjuntarás la dirección IP a un balanceador de cargas más adelante.
Visita la cuenta del proveedor de tu dominio y edita la configuración del dominio. Debes crear un registro A que contenga tu nombre de API, por ejemplo, myapi.example.com con la dirección IP externa en su campo de datos
Crea un grupo de instancias que incluya las instancias en ejecución en la API y el proxy de servicio extensible (ESP):
Haz clic en Definir un servicio de backend > Crear o seleccionar un servicio de backend.
Asigna el nombre y la descripción que desees para esta configuración del servicio de backend.
En el campo Protocolo, selecciona el protocolo que deseas admitir en el balanceador de cargas, HTTP o HTTPS.
En la lista Grupo de instancias, haz clic en tu grupo de instancias.
En el campo Números de puerto, ingresa 8080.
Haz clic en Verificación de estado para configurarla:
Ingresa un nombre para la configuración de verificación de estado.
Asigna el puerto 8080.
Para aceptar los valores predeterminados restantes, haz clic en Guardar.
Por ahora, acepta los valores predeterminados para el resto de la configuración.
Podrás realizar cambios más adelante según sea necesario, por ejemplo, agregar puertos adicionales.
No necesitas establecer nada en las Reglas de host y enrutamiento; puedes reenviar todo a tu API de backend con los filtros predeterminados de Cualquiera que no coincida. Esto significa que todo el tráfico hacia el balanceador de cargas se dirigirá a la API en el puerto 8080 (el puerto predeterminado), como se definió en los pasos anteriores.
Haga clic en Configuración de frontend.
En el campo Protocolo, selecciona el protocolo que deseas admitir en el balanceador de cargas, HTTP o HTTPS.
En la lista IP, haz clic en la dirección IP externa que creaste antes.
Para el protocolo HTTPS, debes usar SSL. En la lista Certificado, haga clic en el certificado que desees.
De manera opcional, si deseas admitir otro protocolo, haz clic en Agregar IP y puerto de frontend, especifica el protocolo, la misma dirección IP externa y un puerto diferente.
Para crear el balanceador de cargas completamente configurado, haz clic en Crear. Si el botón Crear no está habilitado, verifica los componentes que acabas de configurar: debería aparecer una marca de verificación al lado de cada componente de configuración. Si la marca de verificación no está presente, significa que no completaste la configuración.
Después de que tus cambios de DNS se propaguen, las solicitudes se enviarán a tu API mediante el balanceador de cargas.
GKE
Para entregar una API en un dominio de Google Kubernetes Engine (GKE), debes exponer el ESP como un servicio mediante la dirección IP externa que se muestra para la configuración de DNS de tu dominio. Ten en cuenta que GKE realiza el balanceo de cargas de forma automática.
Para exponer tu API como un servicio, haz lo siguiente:
Si todavía no tienes uno, configura un servicio de Kubernetes para los backends de tu API. Crea un archivo de configuración de servicio service.yaml con un contenido similar al siguiente:
Cambia la etiqueta selector para que coincida con tus etiquetas de backend (app: echo-app, en este ejemplo)
Asegúrese de que targetPort coincida con el puerto que usa el ESP configurado en tus backends de API. El ESP usa el puerto 8081 de forma predeterminada.
Implementa el servicio de Kubernetes:
kubectl apply -f service.yaml
Observa la dirección IP externa asignada a tu servicio expuesto:
kubectl get services
El resultado muestra una dirección EXTERNAL-IP similar a la siguiente:
NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-node 10.X.XXX.202 10X.XXX.XX.123 8080/TCP 1m
Cambia la IP externa generada de efímera a estática.
Visita la cuenta del proveedor de tu dominio y edita la configuración del dominio. Debes crear un registro A que contenga tu nombre de API, por ejemplo, myapi.example.com, con la dirección IP externa en su campo de datos.
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Difícil de entender","hardToUnderstand","thumb-down"],["Información o código de muestra incorrectos","incorrectInformationOrSampleCode","thumb-down"],["Faltan la información o los ejemplos que necesito","missingTheInformationSamplesINeed","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-09-04 (UTC)"],[[["\u003cp\u003eThis guide outlines the process of serving an API from a custom domain, such as \u003ccode\u003eexample.com\u003c/code\u003e, as an alternative to using a domain managed by Google.\u003c/p\u003e\n"],["\u003cp\u003eBefore configuring a custom domain, you must acquire a domain name, verify domain ownership, name your API host, obtain an SSL certificate if using SSL, and deploy your API and Extensible Service Proxy (ESP).\u003c/p\u003e\n"],["\u003cp\u003eFor App Engine, you can set your API project to use your verified domain by adding a custom domain for your application.\u003c/p\u003e\n"],["\u003cp\u003eFor Compute Engine, serving an API requires reserving a static external IP address, creating an A record with your API name, creating an instance group, and configuring an HTTP(S) load balancer.\u003c/p\u003e\n"],["\u003cp\u003eFor Google Kubernetes Engine (GKE), you must expose ESP as a service, obtain a static external IP address, and create an A record to direct traffic to your API.\u003c/p\u003e\n"]]],[],null,["# Serving an API from your domain name\n\nOpenAPI \\| [gRPC](/endpoints/docs/grpc/serving-apis-from-domains \"View this page for the Cloud Endpoints gRPC docs\")\n\n\u003cbr /\u003e\n\nThis page shows how to serve an API from a custom domain that you own, for\nexample, `example.com`.\n\nAs an alternative to using your own domain name, you can use a domain name\nmanaged by Google. See\n[Using a domain managed by Google](/endpoints/docs/openapi/configure-endpoints#using_a_domain_managed_by_google)\nfor more information.\n\nBefore you begin\n----------------\n\n- Obtain a domain name from a domain name registrar if you don't already have a domain name to use for your API.\n- [Verify domain ownership](/endpoints/docs/openapi/verify-domain-name).\n- [Name your API host name](/endpoints/docs/openapi/configure-endpoints) with your domain name.\n- If you are using SSL with your domain, obtain and upload your SSL certificate.\n- [Deploy your API and Extensible Service Proxy (ESP)](/endpoints/docs/openapi/deploy-api-backend).\n\nConfigure your API project to use your domain name\n--------------------------------------------------\n\nFollow the instructions in the appropriate tab. \n\n### App Engine\n\nTo set your API project to use your verified domain, follow the instructions\nprovided in\n[Adding a custom domain for your application](/appengine/docs/flexible/python/using-custom-domains-and-ssl)\n\n### Compute Engine\n\nThe recommended way to serve an API from Compute Engine instances is\nto use a load balancer across an instance group. You need to reserve an\nexternal IP address for the domain name and use that external IP address for\nthe load balancer.\n\nTo serve the API from a domain name:\n\n1. Reserve at least one static external IP address in your project: \n\n [Go to the External IP Addresses page](https://console.cloud.google.com/networking/addresses/add)\n 1. Assign any name you want to the reserved IP address\n 2. For **Type** , click **Global**.\n 3. For **Attached to** , click **None**. You attach the IP address to a load balancer later.\n2. Visit your domain provider account and edit your domain settings. You must create an *A record* that contains your API name, for example, `myapi.example.com` with the external IP address in its data field\n3. Create an instance group that includes the instances running your API and Extensible Service Proxy (ESP: \n\n [Go to the Create a New Instance group page](https://console.cloud.google.com/compute/instanceGroups/add)\n 1. Assign any name you want for the group and add a description.\n 2. From the **Zone** list, click the zone used by your API instance.\n 3. In the **Instance definition** list, click **Select existing instances**\n 4. In the **VM Instances** field, add the VM instance running the API.\n 5. Click **Create**.\n4. Create and configure an HTTP(S) load balancer: \n\n [Go to the Create a New HTTP(S) load balancer page](https://console.cloud.google.com/networking/loadbalancing/http/add)\n 1. Click **Define a Backend Service** \\\u003e **Create or select a backend service** . \n 2. Assign any name and description you want for this backend service configuration.\n 3. In the **Protocol** field, select the protocol you want to support through the load balancer, **HTTP** or **HTTPS**.\n 4. In the **Instance group** list, click your instance group.\n 5. In the **Port Numbers** field, enter `8080`.\n 6. Click **Health check** to configure health checks:\n - Enter a name for the health check configuration.\n - Assign the port `8080`.\n - To accept the remaining default values, click **Save**.\n 7. For now, accept the defaults for the rest of the configuration. You can make changes later as needed, such as additional ports.\n 8. You don't need to set anything in the **Host and path rules** ; you can forward everything to your backend API by using the default **Any unmatched** filters. This means that all traffic into the load balancer is directed to the API on the port `8080` (the default port) as defined in the preceding steps.\n 9. Click **Frontend configuration** . \n - In the **Protocol** field, select the protocol you want to support through the load balancer, **HTTP** or **HTTPS**.\n - In the **IP** list, click the external IP address you created earlier.\n - For the HTTPS protocol, you need to use SSL. In the **Certificate** list, click the certificate you want.\n - Optionally, if you want to support another protocol, click **Add frontend IP and port**, specify the protocol, the same external IP address, and a different port.\n 10. To create the fully configured load balancer, click **Create** . If the **Create** button isn't enabled, check the components you just configured: a checkmark should appear beside each of the configuration components. A missing checkmark means you haven't completed the configuration.\n 11. After your DNS changes propagate, requests are sent to your API by using the load balancer.\n | **Note:** If requests aren't making it through to your API backend, check your project's [firewall rules](https://console.cloud.google.com/networking/firewalls/list) to make sure your instances can accept traffic on the default ESP port `8080`. For more information, see [Firewalls](/compute/docs/networking#firewalls).\n\n### GKE\n\nTo serve an API over a domain for\nGoogle Kubernetes Engine (GKE), you need to\nexpose ESP as a service, by using the returned external IP\naddress for your domain's DNS settings. Note that GKE\nautomatically does load balancing for you.\n\nTo expose your API as a service:\n\n1. If you don't have one already, [Configure a Kubernetes service](https://kubernetes.io/docs/tasks/access-application-cluster/connecting-frontend-backend/) for your API backends. Create a service configuration file, `service.yaml`, with content similar to the following: \n\n ```\n apiVersion: v1\n kind: Service\n metadata:\n name: echo\n spec:\n ports:\n - port: 80\n targetPort: 8081\n protocol: TCP\n selector:\n app: echo-app\n type: LoadBalancer\n \n ```\n - Change the `selector` label to match your backend labels (`app: echo-app` in this example)\n - Make sure the `targetPort` matches the port used by ESP configured in your API backends. ESP uses port `8081` by default.\n2. Deploy the Kubernetes service: \n\n ```\n kubectl apply -f service.yaml\n \n ```\n3. View the external IP address assigned to your exposed service: \n\n ```\n kubectl get services\n \n ```\n The output displays an `EXTERNAL-IP` address similar to the following: \n\n ```\n NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE\n hello-node 10.X.XXX.202 10X.XXX.XX.123 8080/TCP 1m\n \n ```\n | **Note:** It takes awhile for the API to be exposed as a service, and the external IP isn't visible until this process is complete. So you might have to run `kubectl get services` several times before you see the IP address.\n4. Change the generated external IP from ephemeral to static. \n\n [Go to the External IP Addresses page](https://console.cloud.google.com/networking/addresses/list)\n 1. Select your external IP address from the list.\n 2. In the **Type** list, click **Static**.\n5. Visit your domain provider account and edit your domain settings. You must create an *A record* that contains your API name, for example, `myapi.example.com`, with the external IP address in its data field.\n\nWhat's next\n-----------\n\n- [Serving multiple APIs from a domain](/endpoints/docs/openapi/deploying-apis-subdomains)"]]
