diff --git a/.changesets/docs_lambertjosh_update_docker_docs_runtime.md b/.changesets/docs_lambertjosh_update_docker_docs_runtime.md new file mode 100644 index 0000000000..767ce9ee6c --- /dev/null +++ b/.changesets/docs_lambertjosh_update_docker_docs_runtime.md @@ -0,0 +1,5 @@ +### Updates the Docker deployment instructions to use the Apollo Runtime container [PR #7734](https://github.com/apollographql/router/pull/7734) + +With the release of the MCP Server, a method to easily deploy Apollo's runtime services was needed. The Apollo Runtime container was designed to address this need, which includes both the Router and MCP Servers in a single Docker container. This PR updates the Router deployment Docker instructions to use this new container. + +By [lambertjosh](https://github.com/lambertjosh) in https://github.com/apollographql/router/pull/7734 \ No newline at end of file diff --git a/docs/source/_sidebar.yaml b/docs/source/_sidebar.yaml index 3f92da369c..8ad53da920 100644 --- a/docs/source/_sidebar.yaml +++ b/docs/source/_sidebar.yaml @@ -200,7 +200,11 @@ items: - label: "Overview" href: "./self-hosted" - label: "Docker" - href: "./self-hosted/containerization/docker" + children: + - label: "Docker with the Apollo Runtime Container" + href: "./self-hosted/containerization/docker" + - label: "Docker with Apollo Router" + href: "./self-hosted/containerization/docker-router-only" - label: "Kubernetes" children: - label: "Quickstart" diff --git a/docs/source/routing/self-hosted/containerization/docker-router-only.mdx b/docs/source/routing/self-hosted/containerization/docker-router-only.mdx new file mode 100644 index 0000000000..21b1d1233e --- /dev/null +++ b/docs/source/routing/self-hosted/containerization/docker-router-only.mdx @@ -0,0 +1,178 @@ +--- +title: Deploying only GraphOS Router in Docker +subtitle: Deploy router-only container image +description: Run an Apollo Router-only container image in Docker with examples covering basic setup, configuration overrides, debugging, and building custom Docker images. +--- + +import ElasticNotice from '../../../../shared/elastic-notice.mdx'; + +This guide provides the following examples of running an Apollo Router container image in Docker: + +* Running a basic example with default configuration. +* Customizing your configuration to override the default configuration. +* Debugging your containerized router. +* Manually specifying a supergraph for your router. +* Building your own router Docker image. + +The [documentation](https://docs.docker.com/engine/reference/run/) for the `docker run` command is a helpful reference for the examples in this guide. + +The exact image version to use depends on which release you wish to use. In the following examples, replace `` with your chosen version, for example `v1.32.0`. + + + +This container image only contains the router. Apollo recommends using the [Apollo Runtime container](docker.mdx), which contains all Apollo runtime services. + +## Basic example running router in Docker + +To run the router, your Docker container must have the [`APOLLO_GRAPH_REF`](/router/configuration/overview#apollo_graph_ref) and [`APOLLO_KEY`](/router/configuration/overview#apollo_key) environment variables set to your graph ref and API key, respectively. + +Below is a basic example of running a router image with Docker, either with `docker run` or `docker compose`. It downloads your supergraph schema from Apollo and uses a default configuration that listens for connections on port `4000`. + +You can use `docker run` with the following example command: + +```bash title="Docker" +docker run -p 4000:4000 \ + --env APOLLO_GRAPH_REF="" \ + --env APOLLO_KEY="" \ + --rm \ + ghcr.io/apollographql/router: +``` + +You can also use `docker compose` with the following example `compose.yaml`: + +```yaml title="compose.yaml" +services: + apollo-router: + image: ghcr.io/apollographql/router: + ports: + - "4000:4000" + environment: + APOLLO_GRAPH_REF: "" + APOLLO_KEY: "" +``` + +Whether you use `docker run` or `docker compose`, make sure to replace `` with whichever version you want to use, and `` and `` with your graph reference and API key, respectively. + +For more complex configurations, such as overriding subgraph URLs or propagating headers, see [Router Configuration](/router/configuration/overview/). + +## Override the configuration + +Apollo's default Docker images include a [basic router configuration](https://github.com/apollographql/router/blob/main/dockerfiles/router.yaml). Inside the container, this file is located at `/dist/config/router.yaml`. + +If you wish to override the default configuration, it is important to preserve aspects of the default configuration. In particular, it is generally important for the router to bind to and listen on the special address of `0.0.0.0` (for all interfaces) to ensure it's exposed on a network interface that's accessible outside of the local container. Without this configuration, the router will only listen on `localhost`. + +You can provide your own configuration from the host environment to the router by mounting your configuration to `/dist/config/router.yaml` as follows: + +```bash {4} +docker run -p 4000:4000 \ + --env APOLLO_GRAPH_REF="" \ + --env APOLLO_KEY="" \ + --mount "type=bind,source=/home/user/router.yaml,target=/dist/config/router.yaml" \ + --rm \ + ghcr.io/apollographql/router: +``` + + + +Both local and container paths must be specified as absolute paths. + + + +In this example we are mounting a file from the host system (`/home/user/router.yaml`) in place of the default configuration provided in the image at `/dist/config/router.yaml`. + +## Passing command-line arguments to the router binary + +By default, the `router` command invoked inside the published container doesn't set any of the [available command-line options](/router/configuration/overview#command-line-options). To set them, append the desired option(s) to the `docker run` command. + +For example, to start the router using the `--log debug` option, use the following `docker run` command with the option added at the end: + +```bash {5} +docker run -p 4000:4000 \ + --env APOLLO_GRAPH_REF="" \ + --env APOLLO_KEY="" \ + --rm \ + ghcr.io/apollographql/router: --log debug +``` + +## Debugging your container + +You can debug your container by setting the `entrypoint` in a `docker run` command: + +```bash +docker run -p 4000:4000 \ + --env APOLLO_GRAPH_REF="" \ + --env APOLLO_KEY="" \ + --mount "type=bind,source=/router.yaml,target=/dist/config/router.yaml" \ + --rm \ + --interactive \ + --tty \ + --entrypoint=bash \ + ghcr.io/apollographql/router: +dist# pwd +/dist +dist# ls +config router schema +dist# exit +exit +``` + +In this example, we've added both interactive and tty flags, and we've changed the entrypoint of the image to be a bash shell. + +### Running the debug container to investigate memory issues + +```bash +docker run -p 4000:4000 \ + --env APOLLO_GRAPH_REF="" \ + --env APOLLO_KEY="" \ + --mount "type=bind,source=/data,target=/dist/data" + --rm \ + ghcr.io/apollographql/router:-debug +``` + +The router runs under the control of [heaptrack](https://github.com/KDE/heaptrack). The heaptrack output is saved to the `/data` directory. The output can be analyzed directly using `heaptrack_gui` or `heaptrack_print` or shared with Apollo support. + +## Specifying the supergraph + +If you don't want to automatically update your supergraph via [Apollo Uplink](/federation/managed-federation/uplink/), or you don't have connectivity to access Apollo Uplink from your environment, you can manually specify the details of your supergraph in a `docker run` command: + +```bash +docker run -p 4000:4000 \ + --mount "type=bind,source=/docker.graphql,target=/dist/schema/local.graphql" \ + --rm \ + ghcr.io/apollographql/router: -c config/router.yaml -s schema/local.graphql +``` + +In this example, we have to mount the local definition of the supergraph into our image, _and_ specify the location of the file. It doesn't have to be mounted in the `/dist/schema` directory, but it's a reasonable location to use. We must specify the configuration file location as well, since overriding the default params will override our default config file location. In this case, since we don't want to change our router configuration but want to make sure it's used, we just specify the default location of the default configuration. + +## Building your own container + + + +This section is aimed at developers familiar with tooling such as `docker` and `git` who wish to make their own DIY container images. The script documented here is not a part of the router product, but an illustrative example of what's involved in making your own images. + + + +In the `dockerfiles/diy` directory, we now provide a script, `build_docker_image.sh` which illustrates how to build your own docker images from either our released tarballs or from a git commit hash or tag. Here's how to use it: + +```bash +% ./build_docker_image.sh -h +Usage: build_docker_image.sh [-b [-r ]] [-d] [] + -b build docker image from the default repo, if not present build from a released version + -d build debug image, router will run under control of heaptrack + -r build docker image from a specified repo, only valid with -b flag + a valid release. If [-b] is specified, this is optional + Example 1: Building HEAD from the repo + build_docker_image.sh -b + Example 2: Building HEAD from a different repo + build_docker_image.sh -b -r /Users/anon/dev/router + Example 3: Building tag from the repo + build_docker_image.sh -b v0.9.1 + Example 4: Building commit hash from the repo + build_docker_image.sh -b 7f7d223f42af34fad35b898d976bc07d0f5440c5 + Example 5: Building tag v0.9.1 from the released version + build_docker_image.sh v0.9.1 + Example 6: Building a debug image with tag v0.9.1 from the released version + build_docker_image.sh -d v0.9.1 +``` + +The example uses [debian:bullseye-slim image](https://hub.docker.com/_/debian/) for the final image build. Feel free to modify the script to use images which better suit your own needs, but be careful if using the `-d` flag because it makes the assumption that there is a `heaptrack` package available to install. \ No newline at end of file diff --git a/docs/source/routing/self-hosted/containerization/docker.mdx b/docs/source/routing/self-hosted/containerization/docker.mdx index f63bf01528..9138d94b11 100644 --- a/docs/source/routing/self-hosted/containerization/docker.mdx +++ b/docs/source/routing/self-hosted/containerization/docker.mdx @@ -1,7 +1,7 @@ --- -title: Deploying GraphOS Router in Docker -subtitle: Deploy router container image -description: Run an Apollo Router container image in Docker with examples covering basic setup, configuration overrides, debugging, and building custom Docker images. +title: Deploying the Apollo Runtime in Docker +subtitle: Run an Apollo Runtime container image in Docker +description: Easily deploy a container with everything you need to serve GraphQL requests using Apollo. --- import ElasticNotice from '../../../../shared/elastic-notice.mdx'; @@ -10,185 +10,96 @@ This guide provides the following examples of running an Apollo Router container * Running a basic example with default configuration. * Customizing your configuration to override the default configuration. -* Debugging your containerized router. * Manually specifying a supergraph for your router. -* Building your own router Docker image. The [documentation](https://docs.docker.com/engine/reference/run/) for the `docker run` command is a helpful reference for the examples in this guide. -The exact image version to use depends on which release you wish to use. In the following examples, replace `` with your chosen version, for example `v1.32.0`. +The exact image version to use depends on which release you wish to use. In the following examples, replace `` with your chosen version. For additional details on versioning, see the [container tags documentation](https://github.com/apollographql/apollo-runtime?tab=readme-ov-file#container-tags). -## Basic example running router in Docker +## Quick start To run the router, your Docker container must have the [`APOLLO_GRAPH_REF`](/router/configuration/overview#apollo_graph_ref) and [`APOLLO_KEY`](/router/configuration/overview#apollo_key) environment variables set to your graph ref and API key, respectively. -Below is a basic example of running a router image with Docker, either with `docker run` or `docker compose`. It downloads your supergraph schema from Apollo and uses a default configuration that listens for connections on port `4000`. +Below is a basic example of running an Apollo Runtime image with Docker. It downloads your supergraph schema from Apollo and uses a default configuration that listens for connections on port `4000`. You can use `docker run` with the following example command: ```bash title="Docker" -docker run -p 4000:4000 \ +docker run \ + -p 4000:4000 \ --env APOLLO_GRAPH_REF="" \ --env APOLLO_KEY="" \ --rm \ - ghcr.io/apollographql/router: -``` - -You can also use `docker compose` with the following example `compose.yaml`: - -```yaml title="compose.yaml" -services: - apollo-router: - image: ghcr.io/apollographql/router: - ports: - - "4000:4000" - environment: - APOLLO_GRAPH_REF: "" - APOLLO_KEY: "" + ghcr.io/apollographql/apollo-runtime:latest ``` -Whether you use `docker run` or `docker compose`, make sure to replace `` with whichever version you want to use, and `` and `` with your graph reference and API key, respectively. +Make sure to replace `` and `` with your graph reference and API key, respectively. -For more complex configurations, such as overriding subgraph URLs or propagating headers, see [Router Configuration](/router/configuration/overview/). +## Enabling MCP -## Override the configuration + -Apollo's default Docker images include a [basic router configuration](https://github.com/apollographql/router/blob/main/dockerfiles/router.yaml). Inside the container, this file is located at `/dist/config/router.yaml`. +This feature is [experimental](/graphos/resources/feature-launch-stages#experimental). For more information about MCP support, review the [MCP documentation](https://www.apollographql.com/docs/apollo-mcp-server). -If you wish to override the default configuration, it is important preserve aspects of the default configuration. In particular, it is generally important for the router to bind to and listen on the special address of `0.0.0.0` (for all interfaces) to ensure it's exposed on a network interface that's accessible outside of the local container. Without this configuration, the router will only listen on `localhost`. + -You can provide your own configuration from the host environment to the router by mounting your configuration to `/dist/config/router.yaml` as follows: +To serve MCP requests, enable the [MCP server](https://www.apollographql.com/docs/apollo-mcp-server) using the `MCP_ENABLE` environment variable. You'll also need to export container port `5000` for HTTP Streamable connections to the MCP server, using the `-p 5000:5000` flag. -```bash {4} -docker run -p 4000:4000 \ +```bash title="Docker" {3, 6} +docker run \ + -p 4000:4000 \ + -p 5000:5000 \ --env APOLLO_GRAPH_REF="" \ --env APOLLO_KEY="" \ - --mount "type=bind,source=/home/user/router.yaml,target=/dist/config/router.yaml" \ + --env MCP_ENABLE=1 \ + --env MCP_UPLINK=1 \ --rm \ - ghcr.io/apollographql/router: + ghcr.io/apollographql/apollo-runtime:latest ``` - - -Both local and container paths must be specified as absolute paths. - - - -In this example we are mounting a file from the host system (`/home/user/router.yaml`) in place of the default configuration provided in the image at `/dist/config/router.yaml`. +## Configuring using local files -## Passing command-line arguments to the router binary +You can provide your own configuration from the host environment to the router by mounting the directory containing your configuration files to `/config` as follows: -By default, the `router` command invoked inside the published container doesn't set any of the [available command-line options](/router/configuration/overview#command-line-options). To set them, append the desired option(s) to the `docker run` command. - -For example, to start the router using the `--log debug` option, use the following `docker run` command with the option added at the end: - -```bash {5} +```bash title="Docker" docker run -p 4000:4000 \ --env APOLLO_GRAPH_REF="" \ --env APOLLO_KEY="" \ + -v <>:/config --rm \ - ghcr.io/apollographql/router: --log debug + ghcr.io/apollographql/apollo-runtime: ``` -## Debugging your container +You can also mount specific files, for example the schema file, by specifying: -You can debug your container by setting the `entrypoint` in a `docker run` command: - -```bash -docker run -p 4000:4000 \ - --env APOLLO_GRAPH_REF="" \ - --env APOLLO_KEY="" \ - --mount "type=bind,source=/router.yaml,target=/dist/config/router.yaml" \ - --rm \ - --interactive \ - --tty \ - --entrypoint=bash \ - ghcr.io/apollographql/router: -dist# pwd -/dist -dist# ls -config router schema -dist# exit -exit -``` - -In this example, we've added both interactive and tty flags, and we've changed the entrypoint of the image to be a bash shell. - -### Running the debug container to investigate memory issues - -```bash -docker run -p 4000:4000 \ - --env APOLLO_GRAPH_REF="" \ - --env APOLLO_KEY="" \ - --mount "type=bind,source=/data,target=/dist/data" - --rm \ - ghcr.io/apollographql/router:-debug +```bash title="Docker" +... +-v <:/config/schema.graphql +... ``` -The router runs under the control of [heaptrack](https://github.com/KDE/heaptrack). The heaptrack output is saved to the `/data` directory. The output can be analyzed directly using `heaptrack_gui` or `heaptrack_print` or shared with Apollo support. - -## Specifying the supergraph +If you wish to override the default router configuration, it is important to preserve aspects of the default configuration. In particular, it is generally important for the router to bind to and listen on the special address of `0.0.0.0` (for all interfaces) to ensure it's exposed on a network interface that's accessible outside of the local container. Without this configuration, the router will only listen on `localhost`. -If you don't want to automatically update your supergraph via [Apollo Uplink](/federation/managed-federation/uplink/), or you don't have connectivity to access Apollo Uplink from your environment, you have two options: +This allows for using local supergraph schemas, persisted query manifests, router configuration, and more. To learn more, [review the documentation](https://github.com/apollographql/apollo-runtime?tab=readme-ov-file#configuring-using-local-files). -### Using a local supergraph file - -You can manually specify the details of your supergraph in a `docker run` command: - -```bash -docker run -p 4000:4000 \ - --mount "type=bind,source=/docker.graphql,target=/dist/schema/local.graphql" \ - --rm \ - ghcr.io/apollographql/router: -c config/router.yaml -s schema/local.graphql -``` - -In this example, we have to mount the local definition of the supergraph into our image, _and_ specify the location of the file. It doesn't have to be mounted in the `/dist/schema` directory, but it's a reasonable location to use. We must specify the configuration file location as well, since overriding the default params will override our default config file location. In this case, since we don't want to change our router configuration but want to make sure it's used, we just specify the default location of the default configuration. - -### Using an OCI image reference + -You can use the `--graph-artifact-reference` option to fetch the supergraph schema from an OCI image: +Both local and container paths must be specified as absolute paths. -```bash -docker run -p 4000:4000 \ - --env APOLLO_KEY="" \ - --env GRAPH_ARTIFACT_REFERENCE="" \ - --rm \ - ghcr.io/apollographql/router: -``` + -When using this option, the router will fetch the schema from the specified OCI image instead of using Apollo Uplink. +## Running a specific Router and MCP version -## Building your own container +The container has a tagging scheme that consists of three parts, the container version, the Apollo Router version, and the MCP Server version, each separated by underscores. - +To learn more, see the [tagging documentation](https://github.com/apollographql/apollo-runtime?tab=readme-ov-file#container-tags). -This section is aimed at developers familiar with tooling such as `docker` and `git` who wish to make their own DIY container images. The script documented here is not a part of the router product, but an illustrative example of what's involved in making your own images. +## Additional router configuration information - +For more complex configurations, such as overriding subgraph URLs or propagating headers, see [Router Configuration](/router/configuration/overview/). -In the `dockerfiles/diy` directory, we now provide a script, `build_docker_image.sh` which illustrates how to build your own docker images from either our released tarballs or from a git commit hash or tag. Here's how to use it: - -```bash -% ./build_docker_image.sh -h -Usage: build_docker_image.sh [-b [-r ]] [-d] [] - -b build docker image from the default repo, if not present build from a released version - -d build debug image, router will run under control of heaptrack - -r build docker image from a specified repo, only valid with -b flag - a valid release. If [-b] is specified, this is optional - Example 1: Building HEAD from the repo - build_docker_image.sh -b - Example 2: Building HEAD from a different repo - build_docker_image.sh -b -r /Users/anon/dev/router - Example 3: Building tag from the repo - build_docker_image.sh -b v0.9.1 - Example 4: Building commit hash from the repo - build_docker_image.sh -b 7f7d223f42af34fad35b898d976bc07d0f5440c5 - Example 5: Building tag v0.9.1 from the released version - build_docker_image.sh v0.9.1 - Example 6: Building a debug image with tag v0.9.1 from the released version - build_docker_image.sh -d v0.9.1 -``` +## Router-only Docker container -The example uses [debian:bullseye-slim image](https://hub.docker.com/_/debian/) for the final image build. Feel free to modify the script to use images which better suit your own needs, but be careful if using the `-d` flag because it makes the assumption that there is a `heaptrack` package available to install. +Learn more about the Docker container that includes only the Apollo Router in the [Router-only Docker container documentation](docker-router-only). diff --git a/docs/source/routing/self-hosted/containerization/index.mdx b/docs/source/routing/self-hosted/containerization/index.mdx index d14b59a332..fd4ad5125f 100644 --- a/docs/source/routing/self-hosted/containerization/index.mdx +++ b/docs/source/routing/self-hosted/containerization/index.mdx @@ -1,7 +1,7 @@ --- -title: Containerizing an Apollo Router -subtitle: Run router images in containers -description: Containerize the Apollo GraphOS Router for portability and scalability. Choose from default or debug images. Deploy in Kubernetes or run in Docker. +title: Using Docker to deploy the Apollo Runtime Container +subtitle: Run Apollo Runtime services in containers +description: Learn how to deploy self-hosted Apollo Runtime services like the router and MCP server using container technologies like Docker, Kubernetes, AWS, Azure, and GCP. --- import ElasticNotice from '../../../../shared/elastic-notice.mdx'; @@ -10,30 +10,22 @@ Apollo provides container images of the Apollo Router Core that you can self-hos -## About router container images +## Docker -Apollo provides container images of the router [on GitHub](https://github.com/apollographql/router/pkgs/container/router) in its container repository. The router images are based on [debian:bullseye-slim](https://hub.docker.com/_/debian/), which is designed to provide constrained, secure, and small images. +### Apollo Runtime container (Recommended) -Each release of the router includes both default (production) and debug images. While each image for a release contains the same build, the debug images have helpful debugging utilities installed and run the router under the control of [heaptrack](https://github.com/KDE/heaptrack). +Apollo provides combined Docker images containing the Apollo Router and MCP Server for easy deployment. The images are available via GitHub, downloadable from the [registry](https://github.com/apollographql/apollo-runtime/pkgs/container/apollo-runtime) and the [repository](https://github.com/apollographql/apollo-runtime). -A router image has the following layout: +For more information on deploying using your container environment: -* A `/dist` directory containing the router executable and licensing details -* A `/dist/config` directory containing a default configuration file, `router.yaml` -* A `/dist/schema` directory for conveniently mounting a locally defined supergraph schema +- [Docker](/graphos/routing/self-hosted/containerization/docker) -## Next steps +### Router only container -While the default behavior of a router image is largely suitable for a basic deployment or development scenario, running a containerized router usually requires configuring the router's HTTP endpoint (and optional health check endpoint) to listen on a non-localhost address. +This image is recommended only for Kubernetes-based deployments, and is used by the [Helm chart](/router/containerization/kubernetes/). For more information on deploying using your container environment: -To learn from examples of customizing and deploying router images in specific environments, see the deployment guides for: - -* [Docker](/router/containerization/docker/) -* [AWS](/graphos/routing/self-hosted/containerization/aws) -* [Azure](/graphos/routing/self-hosted/containerization/azure) -* [GCP](/graphos/routing/self-hosted/containerization/gcp) -* [Kubernetes](/router/containerization/kubernetes/) - -See the Apollo Solutions [example Cloud Foundry deployment](https://github.com/apollosolutions/example-pcf-deployment) for a minimal router configuration and Cloud Foundry manifest file. - - +- [Docker](/graphos/routing/self-hosted/containerization/docker-router-only) +- [AWS using Elastic Container Service (ECS)](/graphos/routing/self-hosted/containerization/aws) +- [Azure using Azure Container Apps](/graphos/routing/self-hosted/containerization/azure) +- [GCP using Google Cloud Run](/graphos/routing/self-hosted/containerization/gcp) +- [Kubernetes](/router/containerization/kubernetes/) diff --git a/docs/source/routing/self-hosted/index.mdx b/docs/source/routing/self-hosted/index.mdx index 4c6d946cb9..8b6ca7a7e5 100644 --- a/docs/source/routing/self-hosted/index.mdx +++ b/docs/source/routing/self-hosted/index.mdx @@ -21,8 +21,8 @@ flowchart LR; For each version of the Apollo Router, Apollo provides: - [A Helm chart for Kubernetes](#kubernetes-using-helm) -- [A binary](#local-binary) - [A Docker image](#container) +- [A binary](#local-binary) ## Kubernetes using Helm @@ -32,20 +32,25 @@ Follow our [Kubernetes quickstart](/graphos/routing/kubernetes/quickstart) to de ## Docker -Apollo provides Docker images for each release of Apollo Router. The images are available via GitHub, downloadable from the `ghcr.io/apollographql/router` and the [router repository](https://github.com/apollographql/router/pkgs/container/router). Both debug and production images are provided. +### Apollo Runtime Container (Recommended) + +Apollo provides the Apollo Runtime Container, which bundles all that's required to run the Apollo Runtime in one place. This includes the Apollo Router and the [Apollo MCP Server](/apollo-mcp-server). + +The images are available via GitHub, downloadable from `ghcr.io/apollographql/apollo-runtime` and the [Apollo Runtime Container repository](https://github.com/apollographql/apollo-runtime). For more information on deploying using your container environment: - [Docker](/graphos/routing/self-hosted/containerization/docker) + +### Router only container + +This image is recommended only for Kubernetes-based deployments, and is used by the [Helm chart](/router/containerization/kubernetes/). For more information on deploying using your container environment: + +- [Docker](/graphos/routing/self-hosted/containerization/docker-router-only) - [AWS using Elastic Container Service (ECS)](/graphos/routing/self-hosted/containerization/aws) - [Azure using Azure Container App](/graphos/routing/self-hosted/containerization/azure) - [GCP using Google Cloud Run](/graphos/routing/self-hosted/containerization/gcp) -Apollo also provides the Apollo Runtime Container, which bundles all that's required to run the Apollo Runtime in one place. This includes the router and the [Apollo MCP Server](/apollo-mcp-server). -The images are available via GitHub, downloadable from the `ghcr.io/apollographql/apollo-runtime` and the [Apollo Runtime Container repository](https://github.com/apollographql/apollo-runtime). - -For more information on deploying and configuring this container, see the [Apollo Runtime Container repository](https://github.com/apollographql/apollo-runtime). - ## Local binary Running the Apollo Router directly from its binary speeds up local development and enables embedded use cases where containers are unavailable.