Deploying a service based on a Docker image with FastAPI

In this tutorial, you will deploy a FastAPI service based on a Docker image. The service provides metrics in Prometheus text format. The service will run at the 0.0.0.0 IP address and on port 9875.

To deploy a service based on a Docker image with FastAPI:

1. Prepare your infrastructure.
2. Prepare a Docker image for the service deployment.
3. Deploy the service in DataSphere.
4. Run a health check for the service you deployed.

If you no longer need the resources you created, delete them.

Getting startedGetting started

Before getting started, register in Yandex Cloud, set up a community, and link your billing account to it.

1. On the DataSphere home page, click Try for free and select an account to log in with: Yandex ID or your working account in the identity federation (SSO).
2. Select the Yandex Cloud Organization organization you are going to use in Yandex Cloud.
3. Create a community.
4. Link your billing account to the DataSphere community you are going to work in. Make sure that you have a billing account linked and its status is ACTIVE or TRIAL_ACTIVE. If you do not have a billing account yet, create one in the DataSphere interface.

Required paid resourcesRequired paid resources

The cost of deploying a service based on a Docker image includes:

• Fee for continuously running node instances (see DataSphere pricing).
• Fee for running code cells for health checks of the deployed service.
• Amount of storage used by Yandex Container Registry data (see Container Registry pricing).

Prepare the infrastructurePrepare the infrastructure

Log in to the Yandex Cloud management console and select the organization you use to access DataSphere. On the Yandex Cloud Billing page, make sure you have a billing account linked.

If you have an active billing account, you can create or select a folder to deploy your infrastructure in, on the cloud page.

Create a folderCreate a folder

Create a registry in Container RegistryCreate a registry in Container Registry

DataSphere can create a node from a Docker image hosted in Yandex Container Registry. To push an image, create a registry.

Create a service account for the DataSphere projectCreate a service account for the DataSphere project

Create an authorized key for a service accountCreate an authorized key for a service account

To allow your service account to get authenticated in Yandex Container Registry, create an authorized key.

Prepare your Docker image for the service deploymentPrepare your Docker image for the service deployment

If you do not have Docker yet, install it.

Create a Docker image for your serviceCreate a Docker image for your service

1. Create a folder to store the Docker image configuration and all the required files, e.g., /home/docker-images.

2. Clone the repository on GitHub and place the files in the folder you created.

3. Run Docker Desktop.

4. In the command shell, navigate to the folder with Dockerfile you created.

   cd docker-images
   

5. Build the Docker image:

   docker build --platform linux/amd64 -t fastapi-docker .
   

Push the Docker image to Container RegistryPush the Docker image to Container Registry

If you do not have the Yandex Cloud command line interface yet, install and initialize it.

Deploy the service in DataSphereDeploy the service in DataSphere

1. Open the DataSphere home page. In the left-hand panel, select Communities.

2. Select a community with a billing account linked.
3. Create a project named Node from Docker.
4. In the project settings, specify:
   • Default folder: data-folder.
   • Service account: sa-for-datasphere.
5. Create a secret named key-for-sa to store the full contents of the authorized key file for the sa-for-datasphere service account.
6. Create a node. To do this, click Create resource in the top-right corner of the project page. In the pop-up window, select Node. Specify the node settings:
   1. Enter fastapi as the node name in the Name field.
   2. Under Docker image:
      • Type: Select Docker.
      • Docker image storage: Select Yandex Container Registry.
      • Image path: Specify the path to the Container Registry image in the cr.yandex/<registry_ID>/<image_name>:<tag> format. You can get it in the management console by copying the full value on the repository page. You can also fill out this field manually. You can get the registry ID in the CLI by running the yc container registry list command.
      • Password secret: Select key-for-sa.
   3. Under Endpoint:
      • Type: Select HTTP.
      • Port: 9875.
   4. Enable Telemetry and specify:
      • Type: Select Prometheus.
      • HTTP path: /metrics.
      • Port: 9875.
   5. Enable Healthcheck and specify:
      • Type: Select HTTP.
      • Path: 0.0.0.0.
      • Port: 9875.
      • Timeout: 1.
      • Interval: 15.
      • Fails threshold: 3.
      • Passes threshold: 3.
   6. Under Folder, select data-folder.
   7. Under Provisioning select the g1.1 configuration.
   8. Click Create.

Run a health check for the service you deployedRun a health check for the service you deployed

1. Select the relevant project in your community or on the DataSphere homepage in the Recent projects tab.

2. In the list of services, select Node.

3. Click the Node from Docker node you created.

4. Go to the Request tab.

5. In the Create test request form, select the GET method.

6. In the Path field, enter /urls.

7. Click Execute to get a complete list of URIs to test performance and metrics.

   Result:

   [
   {
      "path": "/openapi.json",
      "name": "openapi"
   },
   {
      "path": "/docs",
      "name": "swagger_ui_html"
   },
   {
      "path": "/docs/oauth2-redirect",
      "name": "swagger_ui_redirect"
   },
   {
      "path": "/redoc",
      "name": "redoc_html"
   },
   {
      "path": "/metrics",
      "name": "metrics"
   },
   {
      "path": "/",
      "name": "root"
   },
   {
      "path": "/urls",
      "name": "get_all_urls"
   },
   {
      "path": "/health-check",
      "name": "healthcheck"
   }
   ]
   

How to delete the resources you createdHow to delete the resources you created

When deploying and using models, you pay for the uptime of each node instance: from its start to deletion.

If you no longer need the service you deployed, delete the node.

1. Delete the node.
2. Delete the secret.
3. Delete the authorized key of the service account.
4. Delete the Docker image.
5. Delete the Container Registry registry.