DEV Community: Raphael Schubert

Postman tips - Autosave auth token on the session

Raphael Schubert — Mon, 04 Mar 2019 19:55:36 +0000

As a dev, you have to test your API endpoints every time, and if it is a bit evolved, it has a login endpoint that you need to evoke to get the auth token to work.

Imagine you have this response from /api/login endpoint

{
    "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3N1ZWQiOiIyMDE5LTAzLTA0VDE2OjQ2OjAzLjMyMDU1NC0wMzowMCIsImV4cGlyZXMiOiIyMDE5LTAzLTA0VDE2OjQ3OjAzLjMyMDYxOS0wMzowMCIsInNjb3BlcyI6ZmFsc2V9.cbPmdag39wvttxLHHe2BfOHUjM6vHDJ52WvoSxqLLF4g"
}

Normally you need to get the response, copy/paste on your session to be able to use on every endpoint on Postman.

But you can do something best, you can configure your Postman to save the token on your session when you just logged in!

Go on the Tests tab on your Postman:

Put this config:

var jsonData = JSON.parse(responseBody);
pm.environment.set("token", jsonData.token);

Tada!!! This will save the response of the request on the current environment with the var name as token, and now you can use on your routes just configuring it like this:

Now you can just do your login anytime and Postman will automatically save the token on your environment and all endpoints will be able to use it with no efforts.

Enjoy!

Using Masonite as microservice

Raphael Schubert — Sun, 03 Mar 2019 16:06:57 +0000

We have a big project built on top of Django and now we started to break it on a few minor parts to be easy to maintain, update and scale.

So we decided to build some of the microservices with Masonite which is a good python framework and has almost all that we need built-in and ready to use.

So, how to integrate it, without need change much of our current logic?

We decided to basically consume it as a Rest API and built a small SDK that we override our code.

For sample:

class User(models.Model):
    # ...
    def get_user_documents(self):
        from documents.model import Document
        return Document.objects.filter(owner=self)

We know the above relation can be reached with related_name but as we had lots of implementations, it ends on some cases in a cyclic import, so on this sample case, we will use this approach.

So we moved all the documents of users to a new microservice because there we can scale the document server as we need and also improve it without the need to update the core server.

How we changed the class above?

class User(models.Model):
    # ...
    def get_user_documents(self):
        return DocumentsMS().get_user_documents(user_id=self.id)

And on our DocumentMS class, we have few classes that consume the REST API, for sample:

import requests
import json


class DocumentMS:
    def get_user_documents(user_id: int):
        url = "https://......"
        headers = {} # security token header
        querystring = {
            "user_id": user_id
        }

        response = requests.request("GET", url, headers=headers, params=querystring)
        return json.loads(response.text)

All of the codes we just wrote is for sample purposes and give you a simplistic way to use microservices along with your core server without the need to change your logic.

We normally use this for all implementations and then we dive deep as each situation needs.

I hope this gives you the north to how you can use microservices in an easy way.

On the next article I will show how we can create a small API to response the calls we just wrote.

How to create a PIP package hosted on private Github repo

Raphael Schubert — Mon, 21 Jan 2019 16:47:24 +0000

I have few projects with few classes I've developed to integrate multiples services and servers. Those classes are private to my business and now I need an easy way to allow all projects use it and download it and all its updates.

What is the best way? Well, we all use pip everytime to download thousands of packages to our projects and is awesome.

So what can we do with our own private repos? Lets host its project on Github and see what happens.

This articles I'm writing and will share my experience on how to do this. Until the day of this article, I have no idea like you, on HOW it will works.

Lets start our study case.

First steps

Based on this tutorial: https://python-packaging.readthedocs.io/en/latest/minimal.html I'll create my first ever package ready to go to my private pip repo.

Creating root path and start a git

First, I'll create an path, called ptolemaios wich is my main class name and start a new git on it.

$ mkdir ptolemaios
$ cd ptolemaios
$ git init
> Initialized empty Git repository in '...ptolemaios/.git/'

Folder structure

On the tutorial it says I need this folder structure:

ptolemaios/
    ptolemaios/
        __init__.py
    setup.py

so, lets create again one more folder called ptolemaios inside my ptolemaios folder... sounds a little confusing.

$ mkdir ptolemaios

Creating basic files

and lets create the files setup.py and __init__.py

$ touch setup.py
$ touch ptolemaios/__init__.py

ok, now I have the exactly structure on the tutorial. Let's commit it and go to next steps.

$ git add .
$ git commit -am "created basic package structure files and folders"
> 2 files changed, 0 insertions(+), 0 deletions(-)
> create mode 100644 ptolemaios/__init__.py
> create mode 100644 setup.py

MVP Package

As I want to learn how to do it, and check if is working, I'll start by creating a function that just prints something on my screen.

lets open our __init__.py file and edit it

def my_cool_test_method():
    print('It works!')

and also lets open our setup.py and configure the basics about the package

from setuptools import setup

setup(
    name='ptolemaios',
    version='0.0.1',
    description='My private package from private github repo',
    url='git@github.com:rfschubert/ptolemaios-sdk-package.git',
    author='Raphael Schubert',
    author_email='raphael.schubert@digitalbankscorp.com',
    license='unlicense',
    packages=['ptolemaios'],
    zip_safe=False
)

you can customize those infos with all infos you want.

lets commit it

$ git commit -am "updated setup.py and created my_cool_test_method"
> 2 files changed, 19 insertions(+)

I've created my private repo on github already, so now, I'll add it to project and push all commits to my repo

$ git remote add origin git@github.com:rfschubert/ptolemaios-sdk-package.git
$ git push -u origin master
> Counting objects: 9, done.
> Delta compression using up to 8 threads.
> Compressing objects: 100% (6/6), done.
> Writing objects: 100% (9/9), 1.00 KiB | 514.00 KiB/s, done.
> Total 9 (delta 0), reused 0 (delta 0)
> To github.com:rfschubert/ptolemaios-sdk-package.git
>  * [new branch]      master -> master
> Branch 'master' set up to track remote branch 'master' from 'origin'.

now, I want to add it on my running project to see if will work, I'll open any project I have on my machine and try installl it from GitHub using pip.

Installing with `pip`

lets open our terminal inside the project we want to install it and run this command

$ pip install git+ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git
> Collecting git+ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git
>   Cloning ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git to > /private/var/folders/7z/....
> Installing collected packages: ptolemaios
>   Running setup.py install for ptolemaios ... done
> Successfully installed ptolemaios-0.0.1

Here we have few important things. Where I finded this URL?

Well, it is the basic clone url with few modifications.

My ssh clone url is: git@github.com:rfschubert/ptolemaios-sdk-package.git, look at : on ssh url, change it to / and add git+ssh:// on your ssh url

Now you should have git+ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git, that's it! just do pip install git+ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git and be happy!

Lets test it on my project.

I'll go on Django console to test it easy.

import ptolemaios

ptolemaios.my_cool_test_method()
# It works!

AWESOME! I can have now private packages on my project.

Step back

Well, on my computer, all works like a charm, but that's why I have the ssh keys to fetch data from private repository. How my Heroku app will download it ?

first I'll run the command to update my requirements.txt file

$ pip freeze > 'requirements.txt'

now, if I look inside of it, it only has my package name, and not the GIT url

...
ptolemaios==0.0.1
...

you will need change this line to work like expected to:

...
git+ssh://git@github.com/rfschubert/ptolemaios-sdk-package.git
...

so, when your server deploy, it will fetch from repository the current version.

I've founded an answer that can be usefull to some of you, but not to me, I'll need do some more research and update this file later.

You can create a Machine User on GitHub add it to your private repos, generate an ssh key on your server and add it to Machine User, every time you deploy, your server will have the ssh key and will be allowed to download it.

How to deploy to Heroku?

I dont know yet, but I'll find out and I'll be back... let's do some more research...