Hey everyone! đź‘‹ Ever wanted to host your FastAPI application on Google Cloud? You're in luck! This guide will walk you through, step-by-step, on how to get your FastAPI project up and running on Google Cloud Platform (GCP). We'll cover everything from setting up your project and writing a simple FastAPI app, to containerizing it with Docker and deploying it using Cloud Run. So, grab your favorite beverage, buckle up, and let's get started! This is going to be a fun ride, and by the end, you'll have a fully functional FastAPI app in the cloud, ready to handle requests.

    Prerequisites: What You'll Need

    Before we dive in, let's make sure we have everything we need. You'll need a Google Cloud account, a basic understanding of Python, and a little familiarity with the command line. Don't worry if you're a beginner; I'll explain everything as we go. Here’s a checklist:

    • A Google Cloud Account: You'll need an active Google Cloud account. If you don't have one, you can sign up for a free trial, which gives you credits to get started. Head over to the Google Cloud Console (https://console.cloud.google.com/) and sign up.
    • Python Installed: Make sure you have Python installed on your machine. We'll be using Python 3.7 or higher. You can check your Python version by typing python3 --version or python --version in your terminal.
    • Pip (Python Package Installer): Pip is Python's package installer. It should be installed by default when you install Python.
    • Docker (Optional, but Recommended): Docker will help us containerize our app. If you don't have it, you can download it from https://www.docker.com/get-started. Docker makes deployment much easier because it packages your application with all its dependencies.
    • Google Cloud SDK (gcloud): This is the command-line tool for interacting with Google Cloud. You can download and install it from the Google Cloud website. After installation, you'll need to initialize it by running gcloud init in your terminal and following the prompts to authenticate.
    • A Code Editor: You'll need a code editor or IDE, such as VS Code, PyCharm, or Sublime Text, to write your Python code. If you are a beginner, vs code is the most popular editor to use.

    Now that we have all the prerequisites covered, let's move on to setting up our project. Get ready to create your first FastAPI app and deploy it to the cloud. You’ll be able to create a fully functional web application in no time, and the best part is that it can handle multiple users simultaneously. Remember, every great project starts with a single step, so let’s get moving!

    Setting Up Your FastAPI Project

    Alright, let’s get our hands dirty and create a new FastAPI project. This part is super easy and fun. We’ll start by creating a new directory for our project, and then we’ll set up a virtual environment to manage our dependencies. This ensures that our project's dependencies don't interfere with other Python projects on your system.

    1. Create a Project Directory: Open your terminal and create a new directory for your project. You can name it whatever you like; I'll call mine fastapi-gcp-example.

      mkdir fastapi-gcp-example
cd fastapi-gcp-example

    2. Create a Virtual Environment: It's good practice to create a virtual environment to isolate your project's dependencies. This keeps your project clean and avoids conflicts.

      python3 -m venv .venv

      Or, if you prefer to use venv instead of python3 -m venv:

      python -m venv .venv

    3. Activate the Virtual Environment: Activate the virtual environment. This step varies slightly depending on your operating system:

      • Linux/macOS:

        source .venv/bin/activate

      • Windows:

        .venv\Scripts\activate

      You should see (.venv) or something similar at the beginning of your terminal prompt, indicating that your virtual environment is active.

    4. Install FastAPI and Uvicorn: Now, let's install FastAPI and Uvicorn, which will be our web server.

      pip install fastapi uvicorn

    5. Create Your FastAPI App: Create a file named main.py in your project directory. This is where we'll write our FastAPI application code.

      # main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, FastAPI on Google Cloud!"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}

      This simple app defines two endpoints: the root path ("/") and an item endpoint. It's a great starting point.

    6. Test Your App Locally: Before deploying, it’s always a good idea to test your app locally. Run the following command in your terminal:

      uvicorn main:app --reload

      This command starts the Uvicorn server, and the --reload flag enables automatic reloading whenever you make changes to your code. Open your browser and go to http://127.0.0.1:8000. You should see the “Hello, FastAPI on Google Cloud!” message. You can also test the item endpoint by going to http://127.0.0.1:8000/items/5?q=test.

    Congratulations! You've set up your FastAPI project and tested it locally. Next, we'll containerize it with Docker to prepare it for deployment to Google Cloud.

    Containerizing Your App with Docker

    Now, let's containerize our FastAPI application using Docker. This is a crucial step for deploying to the cloud, as it packages our app with all its dependencies in an isolated environment. Docker ensures that your application runs consistently across different environments, including Google Cloud.

    1. Create a Dockerfile: In your project directory, create a file named Dockerfile (without any file extension). This file contains instructions for building the Docker image.

      # Use the official Python image as a parent image.
FROM python:3.9-slim-buster

# Set the working directory in the container to /app.
WORKDIR /app

# Copy the requirements file into the container.
COPY requirements.txt .

# Install any needed packages specified in requirements.txt.
RUN pip install --no-cache-dir -r requirements.txt

# Copy the current directory contents into the container at /app.
COPY . .

# Expose port 8000.
EXPOSE 8000

# Define environment variable.
ENV NAME World

# Run the application when the container starts.
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

      Let's break down this Dockerfile:

      • FROM python:3.9-slim-buster: We're using a slim version of the Python 3.9 image as our base. The slim version is smaller, making your image smaller and faster to deploy.
      • WORKDIR /app: Sets the working directory inside the container.
      • COPY requirements.txt .: Copies the requirements.txt file (which we'll create next) into the container.
      • RUN pip install --no-cache-dir -r requirements.txt: Installs the dependencies listed in requirements.txt. The --no-cache-dir flag optimizes the build process by not caching the downloaded packages.
      • COPY . .: Copies all the project files into the container.
      • EXPOSE 8000: Exposes port 8000, which is where our FastAPI app will run.
      • ENV NAME World: Sets an environment variable.
      • CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]: This is the command that runs when the container starts. It starts Uvicorn, serving our FastAPI app on all interfaces (0.0.0.0) and port 8000.

    2. Create requirements.txt: Create a file named requirements.txt in the same directory as your Dockerfile. This file lists all the Python packages your app depends on.

      fastapi
uvicorn

      When using more complex projects, you may need other dependencies like requests, sqlalchemy, or pydantic. The essential part is to list all your project's dependencies in this file.

    3. Build the Docker Image: Now, let’s build the Docker image. In your terminal, run the following command from your project directory:

      docker build -t fastapi-gcp-example .
      • docker build: This command builds a Docker image from a Dockerfile.
      • -t fastapi-gcp-example: This tags the image with the name fastapi-gcp-example. You can choose any name you like.
      • .: This specifies the build context, which is the current directory. Docker will use the contents of this directory to build the image.

      The build process might take a few minutes, depending on your internet connection and the number of dependencies. Docker will download the necessary base images, install the packages, and create your image.

    4. Test the Docker Image Locally: After the image is built, you can run it locally to make sure everything works correctly.

      docker run -p 8000:8000 fastapi-gcp-example
      • docker run: This command runs a Docker container from an image.
      • -p 8000:8000: This publishes the container's port 8000 to your host machine's port 8000. This is how you access your app.
      • fastapi-gcp-example: This specifies the image name.

      Open your browser and go to http://127.0.0.1:8000. You should see the “Hello, FastAPI on Google Cloud!” message. The Docker image should be working properly. You can also test the item endpoint by going to http://127.0.0.1:8000/items/5?q=test.

    Now that we’ve successfully containerized our app with Docker, we're ready to deploy it to Google Cloud. This makes sure that your application works the same way on every machine.

    Deploying to Google Cloud Run

    Finally, let’s deploy our FastAPI app to Google Cloud Run. Cloud Run is a fully managed compute platform that lets you run containerized applications. It’s serverless, which means you don’t have to manage any infrastructure, and it automatically scales your app based on demand.

    1. Enable Cloud Run API: Before deploying, you need to enable the Cloud Run API in your Google Cloud project. You can do this through the Google Cloud Console or the gcloud command-line tool.

      • Using the Google Cloud Console: Go to the Cloud Run page in the Google Cloud Console and follow the prompts to enable the API.

      • Using gcloud: Run the following command in your terminal:

        gcloud services enable run.googleapis.com

    2. Build and Push the Docker Image to Google Container Registry (GCR): Before deploying to Cloud Run, we need to push our Docker image to Google Container Registry (GCR), which is Google Cloud's container registry service. This makes the image available for Cloud Run to pull.

      # Configure gcloud to use your project.
gcloud config set project YOUR_PROJECT_ID

# Build and push the Docker image to GCR.
docker build -t gcr.io/YOUR_PROJECT_ID/fastapi-gcp-example .
docker push gcr.io/YOUR_PROJECT_ID/fastapi-gcp-example

      Replace YOUR_PROJECT_ID with your Google Cloud project ID. You can find your project ID in the Google Cloud Console. This process might take a few minutes, depending on the image size and your internet connection.

    3. Deploy to Cloud Run: Now, let's deploy the container to Cloud Run using the gcloud command.

      gcloud run deploy fastapi-gcp-example \    
--image gcr.io/YOUR_PROJECT_ID/fastapi-gcp-example \    
--platform managed \    
--region YOUR_REGION \    
--allow-unauthenticated
      • gcloud run deploy: This command deploys a service to Cloud Run.
      • fastapi-gcp-example: This is the name of your Cloud Run service.
      • --image: Specifies the Docker image to deploy. Make sure this is the image you pushed to GCR.
      • --platform managed: Specifies that you want to deploy to the managed platform (Cloud Run).
      • --region: Specifies the Google Cloud region where you want to deploy your service (e.g., us-central1, europe-west1). Choose the region closest to your users for better performance.
      • --allow-unauthenticated: This allows unauthenticated access to your service, making it accessible to anyone with the URL. Remove this flag if you want to implement authentication.

      Follow the prompts in the terminal. The deployment process will take a few minutes. Once the deployment is complete, gcloud will provide a URL for your deployed service. You can use this URL to access your FastAPI app.

    4. Access Your Deployed App: Open the URL provided by gcloud in your browser. You should see the “Hello, FastAPI on Google Cloud!” message. You can also test the item endpoint by adding /items/5?q=test to the end of the URL.

    Congratulations! Your FastAPI app is now deployed and running on Google Cloud Run. Your application is now accessible from anywhere in the world, and it will automatically scale to handle the traffic. You have successfully taken your FastAPI application from your local machine and deployed it to the cloud. You can share the URL with your friends, colleagues, or anyone who needs access to your application.

    (Optional) Setting up a Custom Domain

    Want to use a custom domain for your FastAPI app? You can easily set that up with Cloud Run. Here’s a quick guide:

    1. Verify Your Domain: First, you'll need to verify your domain in Google Cloud. Go to the Cloud Run page in the Google Cloud Console, and click on

Lastest News