With the release of Google’s Cloud Run, I decided to check it out with my nasnet container.
With Cloud Run, you simply deploy your container and let Google scale it based on the requests it receives. When your container is not used, it gets scaled to zero. As such, it combines the properties of a serverless offering such as Azure Functions with standard containers. Today, you cannot put limits on scaling (e.g. max X instances).
You might be tempted to compare Cloud Run to something like Azure Container Instances but it is not exactly the same. True, Azure Container Instances (ACI) allows you to simply deploy a container without the need for an orchestrator such as Kubernetes. With ACI however, memory and CPU capacity are reserved and it does not scale your container based on the requests it receives. ACI can be used in conjunction with virtual nodes in AKS (Kubernetes on Azure) to achieve somewhat similar results at higher cost and complexity. However, ACI can be used in broader scenarios such as stateful applications beyond the simple HTTP use case.
Prerequisites
Cloud Run containers should be able to fit in 2GB of memory. They should be stateless and all computation should be scoped to a HTTP request.
Your container needs to be invocable via HTTP requests on port 8080. It is against best practices though to hardcode this port. Instead, you should check the PORT environment variable that is automatically injected into the container by Cloud Run. Google might change the port in the future! In the nasnet container, the code checks this as follows:
port := getEnv("PORT", "9090")
getEnv is a custom function that checks the environment variable. If it is not set, port is set to the value of the second parameter:
func getEnv(key, fallback string) string {
value, exists := os.LookupEnv(key)
if !exists {
value = fallback
}
return value
}
Later, in the call to ListenAndServe, the port variable is used as follows:
log.Fatal(http.ListenAndServe(":"+port, nil))
Deploying to Cloud Run
Make sure you have access to Google Cloud and create a project. I created a project called CRTest.
Next, clone the nasnet-go repository:
git clone https://github.com/gbaeke/nasnet-go.git
If you have Docker installed, issue the following command to build and tag the container (from the nasnet-go folder which is a folder created by the git clone command above):
docker build -t gcr.io/<PROJECT>/nasnet:latest .
In the above command, replace <PROJECT> with your Google Cloud project name.
To push the container image to the Google Cloud Repository, install gcloud. When you run gcloud init, you will have to authenticate to Google Cloud. We install gcloud here to make the authentication process to Google Container Registry easier. To do that, run the following command:
gcloud auth configure-docker
Next, authenticate to the registry:
docker login gcr.io/<PROJECT>
Now that you are logged in, push the image:
docker push gcr.io/<PROJECT>/nasnet:latest
If you don’t want to bother yourself with local build and push, you can use Google Cloud Build instead:
gcloud builds submit --tag gcr.io/crtest/nasnet .
The above command will package you source files, submit them to Cloud Build and build the container in Google Cloud. When finished, the container image will be pushed to gcr.io/crtest. Either way, when the push is done, check the image in the console:
Now we have the image in the repository, we can use it with Cloud Run. In the console, navigate to Cloud Run and click Create Service:
By default, allocated memory is set to 256MB which is too low for this image. Set allocated memory to 1GB. If you set it too low, your container will be restarted. Click Optional Settings and change the allocated memory:
Note: this particular container writes files you upload to the local file system; this is not recommended since data written to the file system is counted as memory
Note: the container will handle multiple requests up to a maximum of 80; currently 80 concurrent requests per container is the maximum
Now finish the configuration. The image will be pulled and the Cloud Run service will be started:
Cloud Run gives you a https URL to connect to your container. You can configure custom domains as well. When you browse to the URL, you should see the following:
Try it by uploading an image to classify it!
Conclusion
Google Cloud Run makes it easy to deploy HTTP invocable containers in a serverless fashion. In this example, I modified the nasnet code to check the PORT environment variable. In the runtime configuation, I set the amount of memory to 1GB. That was all that was needed to get this container to run. Note that Cloud Run can also be used in conjunction with GKE (Google Kubernetes Engine). That’s a post for some other time!
baeke.info 