Serverless Python Quickstart with Google Cloud Functions 
Tags: python, cloudfunctions, serverless
Published: 2019-04-18 20:06:40

---
title: Serverless Python Quickstart with Google Cloud Functions 
published: true
description: How to write your first Cloud Function in Python
tags: python, cloudfunctions, serverless
---

There's a new runtime in town: the Google Cloud team has brought everything awesome about Python to Google Cloud Functions by releasing a Python 3.7 runtime in addition to the existing Node.js runtime.

Cloud Functions are great for writing lightweight, self-contained microapps that can be individually scaled (and are a fraction of the cost of deploying a full webapp). They can also be used as "triggers": for example, automatically resizing an image into a smaller thumbnail once it's uploaded to a Google Cloud Storage bucket.

And now that you can write Cloud Functions in Python, you have the full power of the Python language (and any package from PyPI) at your disposal.

# Initial setup

Cloud Functions have a simple directory structure:

```
.
├── main.py
└── requirements.txt
```

In `main.py`, we'll define our function. In `requirements.txt`, we'll add any requirements that we might need to install from PyPI (or just leave it empty if there aren't any).

# Writing our function

To start, let's write a simple function in our `main.py` file that just says hello:

```python
def hello(request):
    return "Hello World!"
```

# Running locally

To quickly test out our function, we can run it locally before deploying.

You'll need Python installed to follow this part. If you don't yet, see ["Setting Up A Python Development Environment"](https://cloud.google.com/python/setup).

Once you've got a Python environment locally, we can add the following code to the end of our `main.py` file:

```python
if __name__ == '__main__':
    from flask import Flask, request
    app = Flask(__name__)
    app.route('/')(lambda: hello(request))
    app.run()
```

Next, create a virtual environment, activate it, and install Flask:

```
$ python -m venv env
$ source env/bin/activate
(env) $ pip install flask
Collecting flask
  ...
Successfully installed Jinja2-2.10 MarkupSafe-1.0 Werkzeug-0.14.1 click-6.7
flask-1.0.2 itsdangerous-0.24
```

Run it as follows:

```
$ python main.py
```

...and visit <http://localhost:5000> to see your endpoint locally.

# Deploying our function

Our function is only useful if it's deployed! Before deploying our function, you'll need to [install and initialize the `gcloud` command line tool](https://cloud.google.com/sdk/docs/).

Once the `gcloud` SDK is installed, we can deploy our function with one line:

```
$ gcloud beta functions deploy hello --trigger-http --runtime python37 --project YOUR_PROJECT_NAME
```

Once deployed, this command will give you a link to your live function.

# Passing in variables

You're probably going to want to pass some data into your function. One way to do this is via URL parameters, like `http://foo.bar/hello?name=Dustin`. Let's make our example optionally take a parameter called `name` and use that instead of "World":

```python
def hello(request):
    name = request.args.get('name', 'World')
    return f"Hello {name}!"
```

Then when we redeploying our function, and visit `https://YOUR_PROJECT_NAME.cloudfunctions.net/hello?name=dev.to`, it will say:

> Hello dev.to!

# Adding dependencies

One of the nice things about Cloud Functions is that you can install the same dependencies from PyPI that you would normally use anywhere else.

Let's add a dependency on the [`emoji`](https://pypi.org/project/emoji/) package, so we can add an optional emoji to the end of our message as well.

We'll add the name and version of the package to our `requirements.txt` file:

```
emoji==0.5.1
```

This will automatically get installed when we redeploy the function.

Next, we'll want to import and use the library in our function:


```python
import emoji

def hello(request):
    name = request.args.get('name', 'World')
    reaction = emoji.emojize(request.args.get('reaction', '!'))
    return f"Hello {name} {reaction}"
```

Then we can visit `https://YOUR_PROJECT_NAME.cloudfunctions.net/hello?name=dev.to&reaction=:wave:` and it will say:

> Hello dev.to 👋

# Next steps
There's lots more you can do with Cloud Functions! Follow the links below to learn how to:

* [Write "background" trigger functions that respond to events](https://cloud.google.com/functions/docs/writing/background)
* [Monitor functions at a high level with Stackdriver](https://cloud.google.com/functions/docs/monitoring/)
* [See additional tips & tricks for writing Cloud Functions](https://cloud.google.com/functions/docs/bestpractices/tips)

_All code © Google w/ Apache 2 license_