DEV Community: Billy Ferguson

How to put a django app in the cloud.

Billy Ferguson — Mon, 29 Jul 2019 19:26:02 +0000

GKE cluster and CloudSQL, a saga

Yupp, I said saga. So you wanna make a GKE cluster with Django and a CloudSQL (postgres) backend, hold on for the ride.

Alright so you're here and reading this so I'm assuming you're struggling with this.

Here are the prereqs for this post:

you have a django app
you can build a container of that app
you're ok with using postgresql as the SQL backend

If you don't you have one you can use this

Setup project on Google Cloud.

Create project

First thing we need to do before we can setup the project we are going to want to Create a project in order to group all of our cloud components.

You can create a project at https://cloud.console.google.com after you create an account in the top left of the screen. See screenshot below:

Create CloudSQL instance

Create a postgres CloudSQL with a private IP since that is what we are going to need when connecting GKE to cloudSQL, you can technically do it with it being a public IP, but then you need to run a cloud_sql_proxy inside of the django container, so let's not get into that right now, this is actually easier.

After you've created the CloudSQL instance we're going to want to create a database user and a database for our django project and grant CREATE, READ, UPDATE, DELETE to a user that I'll call myproject-user to the database we will call myproject-db.

The things we need to remember from this are the private IP address (can be found under the CONNECTION tab. Database name was myproject-db and the database user was myproject-user and the password that you set when you created the user. We will need this stuff later.

Pushing docker image to Google docker registry (GKE cluster deployment prereq)

Before we create a cluster, we are going to want to figure out what your project ID is in order to use the Google cloud docker registry gcr.io. Here is how you would do it if you were in the directory of the Dockerfile for the django app:

docker build . -t gcr.io/<project-id>/django
docker push gcr.io/<project-id>/django

This will give us an image to deploy to our cluster when we get there.

Creating a cluster

A cluster is a set of nodes that will run your services (instances of workloads, we will get to this).

I suggest if this is your first time to create the smallest physical node type and only create one node. I understand this kinda defeats the purpose, but it will save you money while you're still figuring everything out. Also clicking the Your first cluster template is also a good start, but we need to click the Availability, networking, security, and additional features link near the bottom of the cluster settings, and we are looking to ENABLE the setting VPC-native.

Deploy a workload

After you click deploy under the workload tab you'll get a window that has nginx in the image section, we are gonna wanna use our own. In order to do this you'll want to click the blue SELECT link and navigate to the image we created earlier and here is where I will need you to fill in your environment variables that you set in section above that I said are things to remember.

Exposing a service to the world.

If we go into the Services section and select the service for the workload we just deployed we can PORT Forward the django port to port 80 or whatever port you want!

Important Key takeaways.

The easiest way I could get this to work was to have a VPC-Native enabled GKE cluster and a CloudSQL instance that has the Private IP section enabled.

Support articles

If you messed up Environment variables

If you think you might have setup an environment variable incorrectly go to the Configuration section and you can find a Config Map called <service-name>-config.

Questions, comments, concerns

Feel free to click one of these buttons in order to signal me with something that was messed up with this. I'd be glad to fix anything that didnt work for you.

How I setup my ssh config to be able to use different Gitlab/Github ssh keys.

Billy Ferguson — Wed, 24 Jul 2019 19:20:40 +0000

Backstory

So the original idea for this post actually stemmed from me adding some ssh keys for private gitlab repos to be able to git clone other private repos for building docker containers in our CI/CD stuff, but this was a perfect jump start for an issue that I had and how I solved it

What the problem was.

Well, so you see, last week I setup a new ssh key to use the deploy key feature of Gitlab to give read only access to other computers, in this case it was a gitlab-ci runner, but thats beside the point. Also if you don't know ssh stuff and are still logging in every time you wanna clone/push to a remote git repo I suggest you head over here to a (great Digital Ocean breakdown of ssh connection education](https://www.digitalocean.com/community/tutorials/understanding-the-ssh-encryption-and-connection-process).

A few days after I added the key, upon a restart of my computer, I could no longer clone projects or push changes to remote repos with ssh. I know what it is, ssh is using my newer ssh key by default, lets test that theory!

If I typed ssh -T git@gitlab.com it would say what I expected, a failure right?:

➜  ~ ssh -T git@gitlab.com
Welcome to GitLab, @fergyfresh!

Damn! I was hoping that would fail. Let's try to clone a private repo again:

➜  ~ git clone ssh@gitlab.com:path/to/my/private/repo.git
Cloning into 'repo'...
ssh@gitlab.com: Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

:( so sad. Well, that stinks. I'm lost, or am I?

Solution

So I remember that I had used ~/.ssh/config to specify an Identity before, so we can surely do that again. The file we are going to want to modify is ~/.ssh/config. Or in most cases, like mine, it didn't even exist so I had to create it.

We are going to want to add an entry for a host and the ssh IdentifyFile to use. All of my ssh keys are in the ~/.ssh/ directory:

host gitlab.com
    HostName gitlab.com
    IdentityFile /home/ferg/.ssh/id_rsa
    User git

Now, once you see that you know the power of the ssh config and can extrapolate that setup to use a different ssh key for any number of hosts. Don't forget to have the path to the private key at IdentifyFile to be on your computer and not just blindly cut/paste my path, with MY username.

Questions, comments, concerns

Feel free to click one of these buttons in order to signal me with something that was messed up with this. I'd be glad to fix anything that didnt work for you.

Benchmarking Go and Python

Billy Ferguson — Wed, 24 Jul 2019 19:18:41 +0000

Simple Benchmarking for GET requests between Gin and Flask

Preamble

You need to have Go installed and Python installed for this to work.

Introduction

Just noticed after finishing up all the code for this post that both of these are drinking related (Gin and Flask). After analyzing the go ecosystem for web frameworks (Gin, Martini, Web.go, Beego, Goji, Gorilla) I decided on pitting Gin against Flask. This appeared to be the most straight forward comparison between what I'm comfortable with as one of the more popular python web frameworks, but also it's known as one of the fastest ones of the bunch.

Ideally I would do this in a few files, and probably use gunicorn in production for Python and structure the app differently, but I just wanna build the most stripped down version of this example in ython to compare pure speeds of Flask vs. Gin and the size of their minimal docker builds for just returning a simple JSON object on a get request to the app.

Make a directory called pygo-benchmark and change your current directory to that dir.

Go web-app with Gin

Do this all in a subdirectory within pygo-benchmark, I called it go-stuff, but you can call it whatever you'd like.

Write the file

Lets get to building. I use vim-go so you get a whole package scaffold upon the first vim file.go command. So when I type vim main.go I get:

package main

import "fmt"

func main() {
    fmt.Println("vim-go")
}

So you should also create a file called main.go and add the code above to that file. Now we are going to want to install gin. In order to do this we are going to type go get -u github.com/gin-gonic/gin and that will install the go module for us. Alright, now that we have gin installed lets modify the file to make our main.go use gin now and return a simple json object on a GET to localhost:8080, the default port for this webserver.

package main

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()

    router.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })

    // router runs on :8080 by default
    router.Run()
}

Build and Run

It is pretty simple to build a file with go, go build main.go is all you need. Now you should have an executable file called main in the same directory you're in. If you just run /main in the command line at the same directory you built the file from, it should have some standard output like:

[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)
[GIN-debug] Listening and serving HTTP on :8080

If you've gotten this far congrats you built and ran your first go app!

Python web-app with Flask

Do all of this in a subdirectory in pygo-benchmark, I called it flask-stuff, but once again do whatever you need to here.

Write the file

In order to make this post shorter I'm not going to go through the whole setup, I'm just gonna blurgghhhhh the file out here. Make a file called main.py with the contents below:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def ping():
    return '{"message": "ping"}'

if __name__ == "__main__":
    app.run(host="0.0.0.0")

Build and Run python

So there is no build in python, we will get to that benefit as one the favors Go in our Benchmarking section.

I like to do everything on the commandline in virtualenv, but if you dont mind messing up your packages do whatever you want, this is what I would do in order to get this file running:

virtualenv .venv -p python3.6
source .venv/bin/activate
pip install flask
python main.py

Because of the way this file is setup with the if __name__... stuff we can just run this file from the command line, like this python main.py and we should see something like this if we did it successfully:

(.venv) ➜  flask-stuff ✗ python main.py
 * Serving Flask app "main" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-728-815

Benchmarking the pure speed of each setup.

In python using requests and timeit

Now let's get the standard boilerplate dislaimer out here. You know, the one about how results may vary on the machine that you run the benchmarks on and that you really need to have a multitude of machines in order to really prove out benchmars, yada-yada.

Alright, so with that boring stuff out of the way I LOVEEE using timeit to time stuff in python. You can do multiple runs one after the other in order to find a more valuable benchmark (the average response time).

Since we should have both webservers running as of now in this blog the go server is running on localhost:8080 and the python on at localhost:5000. Lets time them both, shall we?:

pip install requests
python
>>>
>>>import timeit
>>>import requests
>>>
>>> # gin / go
>>> timeit.timeit("requests.get('http://localhost:8080')", setup="import requests", number=10000)
21.956489593023434
>>> # flask / python
>>> timeit.timeit("requests.get('http://localhost:5000')", setup="import requests", number=10000)
34.483878459897824

Cool. So as you can see the the Go option is ~36% faster! That's amazing, no wonder people are going for go > python these days. But then again this isn't the most fair test as we can put a multithreadable WSGI server in front of our python setup. Now onto round two...

Using a new fangled benchmarking tool called wrk

and multithreading all the things! Thanks to a great suggestion by a dedicated reader who tweeted in, I am also adding in a multhreaded benchmark and adding gunicorn to sit in front of our Flask app.

In order to get up to speed with me you'll have to download and make the binary for wrk using the instructions found here and if you look there are more options on the side if you're a Windows/Mac user. Also we are going to wanna pip install gunicorn as well and in the flask-stuff directory we are going to want to type gunicorn -w 8 main:app which tells gunicorn (our multithreaded WSGI server) to use 8 threads (since the output of nproc --all on my machine was 8) and it says look at the main.py file and the app function as the entrypoint for the app.

Now down to benchmarking the two using "a real benchmarking tool" - Some guy named Ben.

➜  go-hello wrk -t8 -c32 -d30s http://127.0.0.1:5000 # flask-python
Running 30s test @ http://127.0.0.1:5000
  8 threads and 32 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     3.58ms    1.70ms  42.16ms   94.75%
    Req/Sec     1.12k   158.54     2.83k    84.48%
  268403 requests in 30.10s, 45.82MB read
Requests/sec:   8917.30
Transfer/sec:      1.52MB
➜  go-hello wrk -t8 -c32 -d30s http://127.0.0.1:8080 # go-gin
Running 30s test @ http://127.0.0.1:8080
  8 threads and 32 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     2.64ms    4.71ms  60.39ms   85.07%
    Req/Sec     6.86k     0.93k   33.27k    82.09%
  1639477 requests in 30.10s, 220.46MB read
Requests/sec:  54471.39
Transfer/sec:      7.32MB

Okay, maybe ben was right, this really shows how much better go is than python. Surprisingly though, the one thing python did have was a more deterministic response time as the stdev of the latency was < 2ms where it was almost 5ms in go.

But once again, this is another benchmark proving out go is faster than python. Req/sec wise go is 6.125 times faster than flask, on average.

Benchmarking for Docker image size.

Alrighty then. I'm just gonna go ahead and say it that this post is TOO freaking long already and you're just not going to get me to breakdown the multistage docker builds I iterated through in order to get the smallest image size for each one.

Python Dockerfile

Lets put this file in the flask-stuff/Dockerfile directory with the contents below:

Our structure should look like this:

flask-stuff
- main.py
- Dockerfile

FROM python:3.6-alpine
COPY . /
WORKDIR /
RUN pip install flask
RUN pip install gunicorn
CMD ["gunicorn"  , "-w", "8", "main:app"]

In order to build this you'd type docker build . -t benchmark/py.

Go Dockerfile

Lets put this file in the go-stuff/Dockerfile directory with the contents below:

Our structure should look like this:

go-stuff
- main.go
- Dockerfile

FROM golang:latest
ADD . .
RUN go get -u github.com/gin-gonic/gin
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .
RUN ls
RUN pwd

FROM alpine:latest  
RUN apk --no-cache add ca-certificates
COPY --from=0 /go/main .
CMD ["./main"]

In order to build this you'd type docker build . -t benchmark/go.

Surely what are the results?!?

I have the results, and my name's not Shirley! Bad joke, I know, but I'm trying to keep you awake here.

Alright so here's the data:

➜  pygo-benchmark docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
benchmark/go        latest              02ef15405471        About an hour ago   21.7MB
benchmark/py        latest              8fd24d5e54f1        About an hour ago   89.6MB
python              3.6-alpine          83d065b0546b        19 hours ago        79MB
golang              latest              901414995ecd        2 weeks ago         816MB
alpine              latest              caf27325b298        3 weeks ago         5.53MB

Now this is astonishing! The benchmark/go image is ~76% smaller than the benchmark/py image. This is because of a few reasons, go literally just needs that one binary main to run, where as python needs all of the supporting libraries because it isn't compiled.

If we used the golang image as a base instead of the alpine image as a base for our benchmark/go image it would be ~835MB. The reason why Go docker images are so small is because you can run them directly on an alpine image, which is ~5MB.

Questions, comments, concerns

Feel free to click one of these buttons in order to signal me with something that was messed up with this. I'd be glad to fix anything that didnt work for you.