Google Cloud Run is a fully managed computing platform that automatically scales your stateless containers. It offers an easy way to deploy and manage your applications without the hassle of server management. One common use case is hosting web services, but what if you need your application to listen on multiple ports? In this guide, we'll explore how to use multiple ports in Google Cloud Run using the Go programming language.

Understanding the Challenge

By default, Google Cloud Run only exposes a single port (port 8080) to the outside world. However, in some scenarios, you might need your application to listen on multiple ports. For example, you might want to run a web server on one port and a WebSocket server on another. This is where some creative configuration comes into play.

Prerequisites

Before we dive into the implementation, make sure you have the following prerequisites:

1. A Google Cloud account.

2. The Google Cloud SDK is installed and authenticated on your local machine.

3. Basic knowledge of the Go programming language.

4. Basic familiarity with Docker.

Steps to Use Multiple Ports in Google Cloud Run

Step 1: Set Up Your Go Application

For this guide, let's assume you have a Go application that uses the net/http package to create an HTTP server. We'll modify this application to listen on multiple ports.

Here's a simple example of a Go application that creates an HTTP server:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!")
    })

    http.ListenAndServe(":8080", nil)
}

Step 2: Modify Your Application to Listen on Multiple Ports

To make your application listen on multiple ports, you'll need to make a few changes. In this example, we'll modify the application to listen on both port 8080 and port 9090.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // Define handlers for each port
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World from port 8080!")
    })
    http.HandleFunc("/websocket", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "WebSocket server on port 9090!")
    })

    // Start HTTP servers on both ports
    go http.ListenAndServe(":8080", nil)
    go http.ListenAndServe(":9090", nil)

    // Block the main goroutine to keep the application running
    select {}
}

In this modified version of the application, we're using two separate http.HandleFunc blocks to define handlers for each port. We're also using goroutines (go keyword) to start the HTTP servers on both ports concurrently. Finally, we use a select{} statement to block the main goroutine and keep the application running.

Step 3: Create a Dockerfile

To deploy your application on Google Cloud Run, you need to containerize it using Docker. Create a Dockerfile in the same directory as your Go application with the following content:

# Use the official Go image as the base image
FROM golang:1.20

# Set the working directory inside the container
WORKDIR /app

# Copy the Go application source code to the container
COPY . .

# Build the Go application
RUN go build -o main .

# Expose the ports your application will listen on
EXPOSE 8080
EXPOSE 9090

# Command to run the application
CMD ["./main"]

Step 4: Build and Test Locally

Before deploying to Google Cloud Run, it's a good practice to test your application locally. Build and run your Docker container:

docker build -t my-multiport-app .
docker run -p 8080:8080 -p 9090:9090 my-multiport-app

You should now be able to access your application at http://localhost:8080 and the WebSocket server at http://localhost:9090/websocket.

Step 5: Deploy to Google Cloud Run

Now that your application works locally, it's time to deploy it to Google Cloud Run.

1. Push your Docker container to a container registry. You can use Google Container Registry, Docker Hub, or any other supported registry.

2. Deploy your container to Google Cloud Run using the gcloud command-line tool:

gcloud run deploy my-multiport-app \
    --image gcr.io/your-project-id/my-multiport-app \
    --port 8080 \
    --port 9090 \
    --allow-unauthenticated

Make sure to replace your-project-id with your actual Google Cloud project ID.

Understanding the Configuration

The magic behind making this setup work on Google Cloud Run lies in the configuration of the --port flag. By specifying multiple port numbers, you're indicating to Cloud Run that your container will listen on those ports.

Conclusion

In this guide, we explored how to use multiple ports in a Google Cloud Run deployment using the Go programming language. By modifying your application to listen on different ports and configuring the deployment with the appropriate ports, you can create complex applications that provide various services through different ports.

Remember that Google Cloud Run is primarily designed to host stateless HTTP applications. While this guide demonstrated how to use multiple ports, it's important to understand the limitations and design your application accordingly.

Happy coding, and may your multi-port applications thrive on Google Cloud Run! 🚀🌐