DEV Community: Alan Njogu

Running a Python Script on Google Cloud in 2023: A Step-by-Step Guide

Alan Njogu — Wed, 31 May 2023 15:47:30 +0000

Introduction

As the demand for scalable and efficient cloud computing solutions continues to grow, Google Cloud Platform (GCP) remains a popular choice among developers. In this blog post, we will explore how to run a Python script on Google Cloud in 2023. Whether you are a beginner or an experienced developer, this step-by-step guide will help you leverage the power of GCP for your Python applications.

Prerequisites:

Before we dive into the process, make sure you have the following prerequisites in place:

A Google Cloud Platform account: Sign up for GCP if you don't already have an account.
Python installed on your local machine: Ensure you have Python installed, preferably version 3.x.
A basic understanding of the command line interface (CLI).
A basic understanding of Git.

Make sure you have a repository set up that contains the Python scripts you want to run on Google Cloud. This could be a repository hosted on a version control platform like GitHub. Having a repository allows you to easily clone the code onto your VM Instance and execute the Python scripts seamlessly. If you haven't set up a repository yet, take some time to create one and ensure it contains the necessary Python scripts you want to deploy.

Let's get started with the process:

Step 1: Set up a Google Cloud project

Log in to the Google Cloud Console using your GCP account credentials.
Create a new project or select an existing one from the project dropdown menu.
Take note of your project ID, as it will be required in later steps.

Step 2: Enable the necessary APIs

In the Google Cloud Console, navigate to the APIs & Services section.
Click on "Library" in the left navigation menu.
Search for "Compute Engine API" and enable it.

Step 3: Create a VM Instance

Click on the hamburger menu in the top-left corner of the console, and select "Compute Engine."

In the Compute Engine section, click on the "CREATE INSTANCE" button to start creating a new VM instance.

Fill in the necessary details to configure your VM instance. Provide a unique name for your VM instance and leave every other setting on default.

Scroll down and click “CREATE”.

Once the VM instance is created, you can monitor its status, connect to it via SSH, manage its network settings, and perform various other actions from the Compute Engine section in the Google Cloud Console.

Step 4: Connect to the VM instance using SSH

Click on the "SSH" button next to the VM instance you want to access. This will open a browser-based SSH terminal.

Step 5: Installing Software and Dependencies

We need to install necessary software and dependencies .i.e. Python, Git, Tmux and pip.
First, you need to update the package manager before installing any software. It's a good practice to update the package manager on your VM instance. Run the following command: sudo apt update.

By default, many Linux distributions come with Python preinstalled. However, if Python is not already installed or you want to install a specific version, you can use the package manager to install it. Run the following command to install Python 3: sudo apt install python3.
Pip is the package installer for Python. To install pip, use the following command: sudo apt install python3-pip.

To install Git, use the following command: sudo apt install git

Install tmux. Tmux is a terminal multiplexer that allows you to run multiple terminal sessions within a single window. Install tmux using the following command: sudo apt install tmux.

Step 6: Cloning the repository

Clone the repository of the project you want to run using git clone <repository_url>providing the repository URL. Replace with the actual URL of the repository you want to clone. This will create a local copy of the repository on your VM instance.
Once the cloning process is complete, navigate to the cloned repository directory using the cd command. For example: cd my-repository.

Replace 'my-repository' with the name of the cloned repository directory.

Step 7: Run the Python script

After navigating to the directory containing the Python file you want to run, use the python3 command to execute the file by running this command: python3 my_script.py.

Replace my_script.py with the name of your Python script.

Note: Before running the Python script, make sure you have any necessary dependencies or requirements installed on your VM instance. You can use pip to install the required packages if needed. If you have a number of dependencies, you can run pip install -r requirements.txt to install them.

Step 8: Monitor the script's output

Once you execute the Python script, monitor the terminal output to ensure it runs successfully. The script may produce some output or perform certain actions based on its functionality.

Step 9: Optional - Detach the process using tmux (recommended for long-running scripts)

If your Python script takes a long time to complete or you want to keep it running 24/7 in the background, it's recommended to use a terminal multiplexer like tmux. This allows you to detach the process and keep it running even if you disconnect from the SSH session.

To use tmux, run the following command to start a new tmux session: tmux new -s mysession.

Replace 'mysession' with a suitable session name of your choice.

Inside the tmux session, navigate to the directory containing the Python script and execute it as mentioned in Step 7. Once the script starts running, you can detach the tmux session by pressing 'Ctrl-b' followed by 'd'. This will detach the session and return you to the normal SSH terminal.

To reattach to the tmux session in the future, use the following command: tmux a -t mysession.

Replace 'mysession' with the name of your tmux session.

Running a Python script on Google Cloud in 2023 opens up a world of possibilities for developers and businesses alike. With the power and flexibility of Google Cloud's infrastructure, you can easily deploy and scale your Python applications to meet the demands of your users. In this step-by-step guide, we covered the process of creating a VM instance, connecting to it, installing Python, pip, Git, and tmux, and running a Python file from a cloned repository.

As the world of technology continues to evolve, Google Cloud remains at the forefront of innovation, providing developers with powerful tools and services to bring their Python applications to life. So, go ahead and unleash the full potential of your Python scripts on Google Cloud.

Setting Up a Great Python Dev Environment with Docker

Alan Njogu — Sat, 11 Mar 2023 06:15:00 +0000

Are you tired of having to set up your Python development environment every time you start a new project? Docker can help you out! In this post, I will guide you through the process of setting up a Python development environment using Docker, starting with cloning a git repo.

Prerequisites

To be able to follow along, make sure you are using VS Code and you have Git installed.

Cloning the git repo

To get started, clone the git repo for your project. In this case, I am working on q-lipa’s API. You can do this by running the following command in your terminal:
git clone https://github.com/Njoguu/qlipa-API.git

Setting Up the Environment

First, make sure that you have installed Docker on your machine. Installation instructions can be found on the Docker website. I already have it installed.

Next, navigate to the directory and create a new file called "requirements.txt" to house all the dependencies required for your app. Additionally, create a directory called "src" where the Python files will be stored.

Create a sample main.py file that will act as a ‘placeholder’ for the app. You can get the code from FastAPI's Tutorial-Guide.

To use Docker with your project, first create a file named “Dockerfile” in the root directory of the project. Dockerfile typically contains instructions for installing dependencies, copying files into the image, and configuring the environment. Once the Dockerfile is created, it can be used to build a Docker image, which can then be used to run containers with the application inside.

Next, add the necessary packages for your Dockerfile, at the time this includes Uvicorn and FastAPI, to the requirements.txt file. Once this is done, you can build your Docker image by adding the following code to the Dockerfile.



# Use the latest Python Version as the base image
FROM python:3.12.0a6-slim-buster

# Setup the working directory for the container
WORKDIR /code

# Copy the requirements file to the container
COPY ./requirements.txt ./

# Install the Python dependencies using Python 
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code to the container
COPY ./ ./

# Setup the command to run when the container starts
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

Building the Docker image

Navigate to the repo directory and build the Docker image by running the following command in your terminal:

docker build -t <your-image-name> .

This will build the Docker image for your Python development environment.

Running the Docker container

Now that the Docker image has been built, you can run the Docker container and start working on your Python project.

Run the following command in your terminal:
docker run -d -p 8000:8000 <your-image-name>

This command starts the Docker container, maps port 8000 on your local machine to port 8000 in the container, and runs the app.

Registering File changes - Using Docker Volumes

This all looks great, but there is a problem. When you change something in the code and refresh the app in the browser, you don’t get the new code/the new changes. This is because the code is in your local machine but the app itself is running inside the container.

To make the changes and make the app register those changes automatically, we use volumes.
SEE 👉 What is a volume?

You can do this by making a few changes to what you use to run the docker image. instead use the following code:

docker run -d -p 8000:8000 -v $(pwd):/code <your-image-name>

This code launches a container and maps port 8000 on your local machine to port 8000 in the container. It also mounts the current working directory on the host machine to the code directory in the container.

Important Note: You may run into an error that typically occurs when you are trying to run a Docker command with a repository name that includes uppercase letters. (I’ve right now just learnt Docker repository names must all be lowercase). I found a fix on StackOverflow.

If you run into the error, use this code:

docker run -d -p 8000:8000 -v "$(pwd):/code" <your-image-name>

When you run the app successfully, and make changes to the code, the app will automatically register the changes, and they will be displayed.

Using an IDE in a Docker Container

There is still a problem though. We can’t really code inside the IDE as the IDE does not recognize the dependencies of the app. If you remember, we did not install the dependencies on the local machine, but inside the container. What we actually want is to have this IDE inside the Docker Container.

To achieve this, you need two VS Code extensions, Docker extension and the Dev Containers extension. Install these two, and then on the bottom left, you should see a little button that when you hover, it says “Open a Remote Window”. Click on it.

As you will see from the options, there are different ways in which you can connect to a remote container. But in our case, since we have an existing container that is already running in the background, click on “Attach to Running Container” and select the container for the project you are working on.

This will open up a new instance of VS Code and this lives inside the Docker Container which we created.

Since this is a whole new environment, you will have to install all necessary extensions again for you to use in your project. In this case, I install the Python extension.

We can now code!

Conclusion

In this post, I have shown you how to set up a great Python development environment using Docker. By cloning a git repo, building a Docker image, and running the Docker container, using Docker Volumes, using an IDE inside a Docker Container.

You can easily set up a consistent Python development environment that can be used across projects. Happy coding!

This project will later require multiple containers though, this is where Docker Compose comes in. It is a tool for defining and running multi-container applications. Stay tuned to learn how to set it up!

Streamline Your Job Search: Product Website Launches, product to be Released in the Future.

Alan Njogu — Fri, 27 Jan 2023 09:23:38 +0000

We are thrilled to announce the launch of our website for our Job Search API product!
This is a big step for us as we work towards revolutionizing the job search process for job seekers and companies alike.

Our website has been designed with user experience in mind, making it easy for you to navigate and find the information you need. It features all the necessary information about our product, including its features.

We know many of you are eagerly waiting for the product to become available, and we want to assure you that it is in the works. We are working tirelessly and we expect to release the API soon.

In the meantime, we invite you to explore our website and sign up for our newsletter to stay informed about the latest updates. We are confident that our Job Search API will be a game-changer and we can’t wait for you to experience it.

jikAPI - The #1 Job Search API in Kenya.

Alan Njogu — Sun, 22 Jan 2023 00:10:39 +0000

Excited to announce that the development of a Job Search API - jikAPI - a powerful tool for all job seekers in Kenya, is underway.

The API allows users to search for job opportunities that have been recently posted by employers in Kenya. It provides a simple and easy-to-use interface for users to find the perfect job for them.

jikAPI offers a variety of search parameters for users to filter their results by. Users can search for jobs by keyword, location, job category, etc.

One of the most useful features of the Job Search API is its real-time updates. As soon as a new job is posted, it is added to the API's database and becomes searchable by users. This means that users will never miss out on a new job opportunity again.

The API will also provide detailed information about each job listing, such as the job title, company, location, and a link to the job listing on the employer's website. This makes it easy for users to apply for jobs they are interested in.

Searching for a job can be a stressful and time-consuming process. That's why jikAPI was created to make the process as easy as possible. With the API, web applications that use it can help their users quickly and easily find job opportunities that are relevant to them, saving them time and effort.

Stay tuned for updates on its progress and release date!