Rémi's Blog

OpenVPN Server in a Docker Container

mimiz33 — Fri, 08 Sep 2017 00:00:00 GMT

Since some months now I’m a kind of digital nomad, and working remotly from Cafés, Train stations, Airports or CoWorking spaces. And often I need to "secure" a little bit my connections.

I am a Docker lover and I also have VPS at OVH, so I decided to try to create my own VPN server in a docker Container and to host it on my VPS Instance.

After a quick search on Google I found this article (in French) and it made the job !

As I wanted to details some part of the tutorial I decided to write mine based done by fred.

We will use the kylemanna/openvpn docker image.

First create the "datas" container

docker run --name ovpn-data -v /etc/openvpn busybox

Create configuration files

Please replace here VPN.SERVERNAME.COM by your server hostname. (should be able to connect through this name)
```
docker run --volumes-from ovpn-data --rm kylemanna/openvpn ovpn_genconfig -u udp://VPN.SERVERNAME.COM
```

Generate RSA Keys

docker run --volumes-from ovpn-data --rm -it kylemanna/openvpn ovpn_initpki

Here is the ouput :

init-pki complete; you may now create a CA or requests.
Your newly created PKI dir is: /etc/openvpn/pki

Generating a 2048 bit RSA private key
........................................+++
.+++
writing new private key to '/etc/openvpn/pki/private/ca.key.XXXXDOmiGB'
Enter PEM pass phrase: (1)
Verifying - Enter PEM pass phrase: (1)

You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.

Common Name (eg: your user, host, or server name) [Easy-RSA CA]: vpn.servername.com (2)

CA creation complete and you may now import and sign cert requests.
Your new CA certificate file for publishing is at:
/etc/openvpn/pki/ca.crt

Generating DH parameters, 2048 bit long safe prime, generator 2
This is going to take a long time (3)

.......................................................................................+...........................................................................................................................................................................................+.......................................................................................+...................................................................................................................................++*++*

DH parameters of size 2048 created at /etc/openvpn/pki/dh.pem

Generating a 2048 bit RSA private key
.............................+++
..............................+++
writing new private key to '/etc/openvpn/pki/private/vpn.servername.com.key.XXXXMkJFIA'
-----
Using configuration from /usr/share/easy-rsa/openssl-1.0.cnf
Enter pass phrase for /etc/openvpn/pki/private/ca.key: (1)
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
commonName            :ASN.1 12:'vpn.servername.com'
Certificate is to be certified until Sep  6 08:42:18 2027 GMT (3650 days)

Write out database with 1 new entries
Data Base Updated
Using configuration from /usr/share/easy-rsa/openssl-1.0.cnf
Enter pass phrase for /etc/openvpn/pki/private/ca.key:

An updated CRL has been created.
CRL file: /etc/openvpn/pki/crl.pem

1	Enter a secured PassPhrase
2	Enter the name you entered before
3	This is not false !!

Now we can start the container

docker run --volumes-from ovpn-data -d -p 1194:1194/udp --cap-add=NET_ADMIN --name openvpn-server kylemanna/openvpn

Now we need to create the clients configuration file :

You will need to do that for all your users.
- Create a file for a user (with password prefered)
  
  This will prompt for a passphrase, wich is the password the user will need to give when it wants to connect
  
  This will also ask you for the Passphrase of the Server Key (defined two steps bedore)
  docker run --volumes-from ovpn-data --rm -it kylemanna/openvpn easyrsa build-client-full USERNAME (1)
  1 Replace USERNAME by the name of the user
- Create a file for a user (without password )
  docker run --volumes-from ovpn-data --rm -it kylemanna/openvpn easyrsa build-client-full USERNAME nopass (1)
  1 Replace USERNAME by the name of the user
- Retreive the client file :
  docker run --volumes-from ovpn-data --rm kylemanna/openvpn ovpn_getclient USERNAME > USERNAME.ovpn (1)
  1 Replace USERNAME by the name of the user

Here we are, now we need to try it ! Copy the ovpn file on your client, then use your default VPN Client Tool (I’m on a Mac Laptop and I currectly use Tunnelblick) to connect.

It should work.

I had to change my DNS settings to use DNS server 8.8.8.8.

Jenkins Docker and Gitlab

mimiz33 — Wed, 09 Aug 2017 00:00:00 GMT

In this blog post I will explain how I configured my Jenkins (running in a docker container) to be able to clone and push on a private Gitlab git repository.

I assume that you have docker and jenkins already installed and running

Create and get the Jenkins key

First get the name (or the ID) of the Jenkins Container :

In a terminal type :

docker ps | grep jenkins

This should return something like that :

CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS              PORTS                                              NAMES
f26fa8c9bef9        jenkins/jenkins:lts   "/bin/tini -- /usr..."   41 hours ago        Up 41 hours         0.0.0.0:8080->8080/tcp, 0.0.0.0:50000->50000/tcp   jenkins

The ID is f26fa8c9bef9 (from first column) and the name is jenkins (from last column).

Then "enter" the container in order to create the SSH key :

docker exec -it jenkins /bin/bash

You need to adapt the name (jenkins) with the container ID or your name.

So now you the terminal prompt should have changed :

jenkins@f26fa8c9bef9:/$

Check if you already have an ssh key :

cat ~/.ssh/id_rsa.pub

If you have something else than cat: /var/jenkins_home/.ssh/id_rsa.pup: No such file or directory then you already have the key so you can directly go to the section

To create the key execute the following command :

ssh-keygen

And do not use passphrase and accept default values :

Generating public/private rsa key pair.
Enter file in which to save the key (/var/jenkins_home/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /var/jenkins_home/.ssh/id_rsa.
Your public key has been saved in /var/jenkins_home/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:MNSY7yiVerfBoYR0vCZZeS9n73cevZJl/ezUoSZcoj8 jenkins@f26fa8c9bef9
The key's randomart image is:
+---[RSA 2048]----+
|     ..=         |
|    ..B o        |
|   . =o= .       |
|    + *o+ +      |
|     * =S= o . ..|
|    o + = o + .o=|
|     o . + + o+o=|
|        . .E+o..*|
|           ....=o|
+----[SHA256]-----+

Then get your public key, by copy / paste the ouptut of this command :

cat ~/.ssh/id_rsa.pub

You should have something like that

jenkins@f26fa8c9:/$ cat ~/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDN6y54DIbEDp2gAgyu8ApzJ/tvxSu6myAkEQL3eUiLiLr5YC+uOalJ4AHkWwlmDWoT6SzlpvR+CQD2xEvsHoEumgTuUn1sNNVisIsyd19ga5yqBobM2/zhAaKtpkkuY9k1wOAZERsEIRm4Q5YTvVjNfIug/ZxVzg0xqJc0w9NGGuKNwOlBaCfjyJrhwdGU79Ijoq8sJ8SuswHc2DzvJWgdfXXd1T7w+NdOKqR+yzF5UXIm2uP6x/rVJ6OuINjFY0ODIkLvJtyvaHsIGAJZP21mJlJRPx18vAr6Phy+YmW2+UgEi2I6jxcQ+DYDT3TbTO+qpc+7KOLnRZyQKwnNu1T jenkins@f26fa8c9

Add your credentials to jenkins

Now you created your SSH key so you can create the Credential.

Go to your jenkins, log in, and and click on left menu item "Credentials", then sub item "System", Select "Global Credentials (unrestricted)"

Then click on "Add Credentials" in left menu.

And fill the form as this :

Kind : SSH Username with private key
Scope : Global (Jenkins, nodes, items, all …)
Username : git
Private Key : From the Jenkins master ~/.ssh
Passphrase : empty (or your pass phrase if you have one)
ID : empty
Description : The Jenkins SSH KEy (or whatever you want)

Then Save.

Add your key to Gitlab

Now you have your ssh key, so go to your gitlab project you want to build with Jenkins, and click on "Settings", then "Repository".

Title : Jenkins (Or anything else)
Key : your public key (the output of the command cat ~/.ssh/id_rsa.pub)

You can check the Write access allowed if you need it.

Then save.

Create a jenkins job

Now, in Jenkins, you can create a job that use your repository, just remember to use the "SSH" version of your repository url :

And it should be able to clone !

Configure docker httpd image

mimiz33 — Thu, 18 May 2017 00:00:00 GMT

Recently I had to publish multiple application on a single machine and all applications will be publicly available on their own domains names.

As I am a docker addict, I want all my applications to be running as a docker container.

Imagine I have the following applications :

name	url	Container Name	Container Port (Expose)
app1	www.app1.lol	app1-container	3000
app2	www.app2.lol	app2-container	4000
app3	www.app3.lol	app3-container	8080

name

url

Container Name

Container Port (Expose)

app1

www.app1.lol

app1-container

3000

app2

www.app2.lol

app2-container

4000

app3

www.app3.lol

app3-container

8080

I assume that all container are running (with or without -P flag)

The thing is that I do not want to install a proxy (Apache or Nginx) on the docker host, so I wanted to create a docker container that will act as a proxy of all my applications

So I decided to use the docker httpd:2.4 image.

Create your project directory : mkdir ~/apache-proxy & cd ~/apache-proxy

Extract httpd.conf

First you will need to "extract" the httpd.conf file from the image to be able to configure your apache server.

So you need to start a docker httpd container in a terminal :

docker run -it --name apacheTmp httpd:2.4

The name apacheTmp is just here to make extraction easy and to show you that this container will be deleted after use…

Then open a new terminal window (or a new sesion if you are doing it remotely)

And copy the httpd.conf file :

docker cp apacheTmp:/usr/local/apache2/conf/httpd.conf ~/apache-proxy

personnaly I prefer to create a copy (to keep the original as it was) : cp ~/apache-proxy/httpd.conf ~/apache-proxy/my-httpd.conf.

Configure apache and vhosts

Now I edited the my-httpd.conf file to enable modules proxy and proxy_http,

I just remove comment on the lines :

LoadModule proxy_module modules/mod_proxy.so

And

LoadModule proxy_http_module modules/mod_proxy_http.so

Then I created, at the end of the files my 3 vhosts

www.app1.lol


  ServerName www.app1.lol
  ProxyPass / http://app1:3000/

www.app2.lol


  ServerName www.app2.lol
  ProxyPass / http://app2:4000/

www.app3.lol


  ServerName www.app3.lol
  ProxyPass / http://app3:8080/

Create Docker Container

Now I can Create my "proxy" docker file :

~/apache-proxy/Dockerfile

FROM httpd:2.4
COPY ./my-httpd.conf /usr/local/apache2/conf/httpd.conf

So I can build now :

docker build -t my/apache-proxy .

Then I can run it :

docker run -d -p 80:80 --link app1-container:app1 --link app3-container:app3 --link app2-container:app2 --name my-proxy my/apache-proxy

And now you should be able to access your 3 apps ….

Node.JS "Require" plays hide-and-seek

mimiz33 — Tue, 18 Apr 2017 00:00:00 GMT

Some times ago (I don’t really remember when), working on a Node.Js project, I realised something about require …

The situation …

Imagine we have some datas in a Json file we want to access in different modules.

datas.json

{
  "version":"0.1",
  "name":"MyApplication"
}

This datas.json is quite short, but for explaining the situation it is more than enough !

Now the code :

index.js

var module1 = require('./module1.js'),
    module2 = require('./module2.js');

module1.log();
module2.log();

module1.js

var myDatas = require('./datas.json');

module.exports = {
  log:function(){
    console.log(myDatas);
  }
}

module2.js

var myDatas = require('./datas.json');

module.exports = {
  log:function(){
    console.log(myDatas);
  }
}

As you can see, module1 and module2 are exactly same.

So if we execute the code, we will have the following output :

output 1

⇒  node index.js
{ version: 'O.1', name: 'MyApplication' }
{ version: 'O.1', name: 'MyApplication' }

Ok, now imagine module1 will modify some value before logging :

module1.js (version 2)

var myDatas = require('./datas.json');

module.exports = {
  log:function(){
    lowerCaseName() (1)
    console.log(myDatas);
  }
}

function lowerCaseName(){
  myDatas.name = myDatas.name.toLowerCase();
}

1	We just add this simple function that will lowerCase the name.

In my idea, this should not affect the module2 as they should be independant, so when I execute the code, here is the output :

output 2

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'myapplication' }(1)

Damned !

Source code

Why

Actually the reason is quite simple, when you require the file datas.json, the require function will create the object and store it in the require.cache object, then next time you use require('./datas.json') to retreive the datas, require will return you the value in that require.cache object.

So it mean that it gives you the reference to the value, so if you change one property of that value, all other modules are affected as you are actually doing the change on the reference in the cache.

This is quite well documented in the Node.js documentation :

Modules are cached after the first time they are loaded. This means (among other things) that every call to require('foo') will get exactly the same object returned, if it would resolve to the same file.

— Node.Js Documentation
https://nodejs.org/api/modules.html#modules_caching

Remember that Node.Js is single thread, it mean for example that the require cache is shared accross all requests

Reflections on solutions to have the desired behaviour

Now I will try to make the code work as desired.

Some of the solutions are not solving the problem, but I wanted to try to see how it works …

The Const way … FAIL

First I wanted to use the new ES6 const instead of var in the line

// replace
var myDatas = require('./datas.json');
// with
const myDatas = require('./datas.json');

output 3

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'myapplication' }(1)

Damned !

But actually, const do not prevent the variable to be modified, but prevent reafectation.

FAIL

Source Code, branch const_way

The delete way … SUCCESS

With this solution, you will delete the reference in the require.cache object before require the datas.json file like this :

module2.js

delete require.cache[require.resolve('./datas.json')];
var myDatas = require('./datas.json');
// Code continue ...

As you may not know how your modules are inserted, you need to add the line on every files that need to use the datas.json file.

In my opinion, this is not very convenient, but it works :

output 4

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'MyApplication' } (1)

Great !

I Think that this solution is the "Quick And Dirty" solution.

SUCCESS

Source Code, branch delete_way

The Proxy Way … SUCCESS

With this solution I imagine to create a Proxy around the json datas, and override the set method, in order to forbid the manipulation of the value.

This approach can be usefull to throw excpetion if someone try to set the property value.

Here is the code :

datasProxy.js

var datas = require('./datas.json'); (1)

module.exports = new Proxy(datas, {
  set:function(){
    return; (2)
  }
});

1	This should be the only location in the app where you require the json file.
2	Here, we just do nothing, but we could throw exception here to reject any modification of any properties.

We also need to change the reference in module1 and module2 :

// Replace
var myDatas = require('./datas.json');
// with
var myDatas = require('./datasProxy');

Can you see a big problem ?

YES, the code in module1 should be updated because now we can not set the property (even locally)

Let’s first execute the code without any modification :

output 5

⇒  node index.js
{ version: 'O.1', name: 'MyApplication' }
{ version: 'O.1', name: 'MyApplication' }

So there is a problem, the first line should display the text MyApplciation in lowercase. So let’s edit the code in module1 to have the desired behaviour.

Here is a working code :

module1.js

var myDatas = Object.assign({}, require('./datasProxy')); (1)

module.exports = {
  log:function(){
    lowerCaseName()
    console.log(myDatas);
  }
}

function lowerCaseName(){
  myDatas.name = myDatas.name.toLowerCase();
}

1	We use `Object.assign()` to create a "copy" of the object in the `module1`

If we look at the output :

output 6

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'MyApplication' }

So it works !

But, as the MDN web site says:

"The Object.assign() method only copies enumerable and own properties from a source object to a target object."

— Mozilla Developper Network
http://devdocs.io/javascript/global_objects/object/assign

Maybe you should use a "clone" function that allow to clone objects deeply (check this with lodash _.clone() for example)

I think this solution is not too bad, but the thing is that you delegate to the module the need to create a copy, maybe this suits your needs, or maybe we can do it in the proxy itself.

I think both solution can be justified, you just need to make a choice.

SUCCESS

Source Code, branch proxy_way

The Clone Way … SUCCESS

This solution is the solution I considered previously.

So with this solution, the "Proxy" (or you can call it, the "wrapper") will create the copy and returns it to the modules :

So edit the Proxy code, and the modules :

datasProxy.js

var datas = require('./datas.json');

module.exports = function(){ (1)
  return clone(datas);
}

function clone(datas){
  return JSON.parse(JSON.stringify(datas)); (2)
}

1	We export a function that need to be called in module to return a copy of the datas
2	Here we use a hack to clone "deeply" an object.

Then edit the modules to call the exported function

module1.js

var myDatas = require('./datasProxy')(); (1)

module.exports = {
  log:function(){
    lowerCaseName()
    console.log(myDatas);
  }
}

function lowerCaseName(){
  myDatas.name = myDatas.name.toLowerCase();
}

1	Call the function to get the copy.

module2.js

var myDatas = require('./datasProxy')(); (1)

module.exports = {
  log:function(){
    console.log(myDatas);
  }
}

1	Call the function to get the copy.

Then execute the code :

output 7

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'MyApplication' }

Great it works !

This is my favorite solution.

SUCCESS

Source Code, branch clone_way

The decache way … SUCCESS

This idea was given to me by Jérémy Morin.

Decache is a Node Module, that remove module from the require cache.

This solution has exactly the same effect than the delete solution I present before. But it make it easier to do.

First you need to install the decache node module :

npm init (1)
npm install decache --save

1	This is not necessary if you already initialise a node project.

Then edit the code :

index.js

var module1 = require('./module1.js'),
    module2 = require('./module2.js');

module1.log();
module2.log();

module1.js

var myDatas = require('./datas.json');

module.exports = {
  log:function(){
    lowerCaseName()
    console.log(myDatas);
  }
}

function lowerCaseName(){
  myDatas.name = myDatas.name.toLowerCase();
}

module2.js

var decache = require('decache'); (1)
decache('./datas.json'); (2)
var myDatas = require('./datas.json');

module.exports = {
    log: function() {
        console.log(myDatas);
    }
}

1	First we need to require the decache module
2	Then we use decache to remove the datas.json file from the cache

Maybe we should use decache from both module1.js and module2.js because if we invert the the two require lines in the index.js file the cache is not removed as we expect.

output 7

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'MyApplication' }

It works !

SUCCESS

Source code, branch decache_way

The import Way (aka. the ES6 way) … FAIL

This idea was also given to me by Jérémy Morin.

As Node.JS (version 7.4.0 on my laptop) is not compatible with the ES6 (import) syntax, we will need to "babelize" (transpile with babel) the code, and for that we need to refactor our code, and initilaze a npm project.

First create a src doirectory and copy all files inside that directory
In a terminal window run the npm init command and answer all question
```
npm init
```
Then install the babel-cli dependency
```
npm install babel-cli --save-dev
```

Create a "build" script

package.json

{
  "name": "require_strange",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "build": "babel src -d lib" (1)
  },
  "author": "",
  "license": "ISC",
  "dependencies": {},
  "devDependencies": {
    "babel-cli": "^6.24.1"
  }
}

1	Now you can use `npm run build` to build from ES6 code

Configure babel :

Install the presets
```
npm install babel-preset-env --save-dev
```
Create the .babelrc
/.babelrc
```
{
  "presets":["env"]
}
```

Edit the Code to convert it to ES6

/src/datas.js

export default {
  "version": "0.1",
  "name": "MyApplication"
};

/src/index.js

import module1 from './module1';
import module2 from './module2';

module1.log();
module2.log();

/src/module1.js

import myDatas from './datas';

export default {
    log: function() {
        lowerCaseName();
        console.log(myDatas);
    }
};

function lowerCaseName() {
    myDatas.name = myDatas.name.toLowerCase();
}

/src/module2.js

import myDatas from './datas';


export default {
    log: function() {
        console.log(myDatas);
    }
}

Build
```
npm run build
```

Run

output 9

⇒  node index.js
{ version: 'O.1', name: 'myapplication' }
{ version: 'O.1', name: 'myapplication' }

As you can see the execution output exactly the same, so this is not a good solution.

FAIL

Source code, branch import_way

Conclusion

As a conclusion, I would say that it is important to understand how the require cache works, that’s why I wrote this article.

In order to solve the problem presented in the introduction, I would use the "clone" solution, by creating a "wrapper" object, maybe using the Proxy from ES6.

Please feel free to make any comments …

Debian Install Node.JS globally with NVM

mimiz33 — Sun, 02 Apr 2017 00:00:00 GMT

Recently I had to install Node.JS on a server and allow all users to be able to use it. As I like the nvm concept to be able to easily install Node.Js, I would like to be able to install Node via NVM, and make Node.Js available for all users. I do not want users to be able to install their own version of Node.JS, and I want to control the Node.js global packages on that computer.

So we will do the following

Install some usefull packages

Run as root

apt-get install git vim curl build-essential sudo

Install nvm as "root" / superuser

First you need to clone the nvm repository :

clone nvm

git clone https://github.com/creationix/nvm.git /opt/nvm

Then create the directory /usr/local/nvm

create diretory

mkdir /usr/local/nvm

The edit the ~/.bashrc and add the following line to the file :

~/.bashrc

export NVM_DIR=/usr/local/nvm
source /opt/nvm/nvm.sh

Then logout and login again, or type source ~/.bashrc to enable nvm

Try nvm :

try nvm

nvm install 6.10.1

Now nvm is installed for root, but not all users.

To activate the node installation for users, we will add the script /etc/profile.d/nvm.sh :

/etc/profile.d/nvm.sh

#!/bin/bash
VERSION=`cat /usr/local/nvm/alias/default`
export PATH="/usr/local/nvm/versions/node/v$VERSION/bin:$PATH"

Then make that file runnable : chmod +x /etc/profile.d/nvm.sh

As user

Now connect as a user, and try to use node :

try node

node -v

You should see the node version installed before (6.10.1)

Then try to install a new version of node :

try node

nvm install 7.8.0

Result should be nvm : commande introuvable

Install some global packages

With node you may want to install some package globbaly (forever for example), and I think we should not allow users to install what they want so we may install global packages as root also.

As root run the command npm install -g nodemon for example, then login as a user, and run nodemon index.js and it works.

So all global package should be installed as root (or other superuser).

Use Authorization Header with Swagger

mimiz33 — Mon, 05 Dec 2016 00:00:00 GMT

Recently, on a project I had to document an API using Swagger, as an authentication mechanism, the API, is using JWT.

The Token needs to be set in the Authorization Header of the HTTP request as this :

Authorization Bearer: JWT-token

As we wanted to use the Swagger UI to allow clients to test requests and responses of the API.

To define the API, we use the Swagger Editor Online.

Start the Documentation and the /login route

First we need to create the main API description :

swagger: '2.0'
info:
 version: 0.0.1
 title: MY-SUPERB-API
host: '127.0.0.1:4000'
schemes:
 - http
 - https
produces:
 - application/json
paths:
 /login:
  post:
   tags:
    - auth
   description: |
    Allow users to log in, and to receive a Token
   parameters:
    -
     in: body
     name: body
     description: The email/password
     required: true
     schema:
      $ref: '#/definitions/Login'
   responses:
    '200':
     description: Login Success
     schema:
      $ref: '#/definitions/Token'
    '400':
     description: Whether the user is not found or error while login
     schema:
      $ref: '#/definitions/Error'
    '403':
     description: >-
      If user is not found (bad credentials) OR if user can not login (a
      concierge of an unsctive client)
     schema:
      $ref: '#/definitions/Error'
definitions:
 Login:
  type: object
  properties:
   email:
    type: string
   password:
    type: string
 Token:
  type: object
  properties:
   token:
    type: string
 Error:
  type: object
  properties:
   message:
    type: string
   error:
    type: string

This will define the /login route that receive a POST HTTP request with email and password, if they matches your credential provider the route will return a Token response :

{
  "token":"JWT TOKEN"
}

Describe the Security Definition

Now we should define create a securityDefinitions, this will describe how authorization is made, and allow the Swagger UI to ask for a token when needed.

So first edit the API definition :

swagger: '2.0'
info:
 version: 0.0.1
 title: MY-SUPERB-API
host: '127.0.0.1:4000'
schemes:
 - http
 - https
produces:
 - application/json
securityDefinitions: (1)
 Bearer:
  description: |
   For accessing the API a valid JWT token must be passed in all the queries in
   the 'Authorization' header.


   A valid JWT token is generated by the API and retourned as answer of a call
   to the route /login giving a valid user & password.


   The following syntax must be used in the 'Authorization' header :

       Bearer: xxxxxx.yyyyyyy.zzzzzz
  type: apiKey
  name: Authorization
  in: header
paths:
 /login:
  post:
   tags:
    - auth
   description: |
    Allow users to log in, and to receive a Token
   parameters:
    -
     in: body
     name: body
     description: The email/password
     required: true
     schema:
      $ref: '#/definitions/Login'
   responses:
    '200':
     description: Login Success
     schema:
      $ref: '#/definitions/Token'
    '400':
     description: Whether the user is not found or error while login
     schema:
      $ref: '#/definitions/Error'
    '403':
     description: >-
      If user is not found (bad credentials) OR if user can not login (a
      concierge of an unsctive client)
     schema:
      $ref: '#/definitions/Error'
definitions:
 Login:
  type: object
  properties:
   email:
    type: string
   password:
    type: string
 Token:
  type: object
  properties:
   token:
    type: string
 Error:
  type: object
  properties:
   message:
    type: string
   error:
    type: string

1	Ajout de la clé securityDefinitions

The description is, I think, self described, so you can understand it

Create a protected route

And now you can define a route /users for example that needs the user to send a valid Authorization header …

swagger: '2.0'
info:
 version: 0.0.1
 title: MY-SUPERB-API
host: '127.0.0.1:4000'
schemes:
 - http
 - https
produces:
 - application/json
securityDefinitions:
 Bearer:
  description: |
   For accessing the API a valid JWT token must be passed in all the queries in
   the 'Authorization' header.


   A valid JWT token is generated by the API and retourned as answer of a call
   to the route /login giving a valid user & password.


   The following syntax must be used in the 'Authorization' header :

       Bearer: xxxxxx.yyyyyyy.zzzzzz
  type: apiKey
  name: Authorization
  in: header
paths:
 /login:
  post:
   tags:
    - auth
   description: |
    Allow users to log in, and to receive a Token
   parameters:
    -
     in: body
     name: body
     description: The email/password
     required: true
     schema:
      $ref: '#/definitions/Login'
   responses:
    '200':
     description: Login Success
     schema:
      $ref: '#/definitions/Token'
    '400':
     description: Whether the user is not found or error while login
     schema:
      $ref: '#/definitions/Error'
    '403':
     description: >-
      If user is not found (bad credentials) OR if user can not login (a
      concierge of an unsctive client)
     schema:
      $ref: '#/definitions/Error'
 /users:
  get:
   tags:
    - users
   security:
    - Bearer: []
   description: Get a list of all existing users
   responses:
    '200':
     description: An array of users
     schema:
      type: array
      items:
       $ref: '#/definitions/User'
definitions:
 Login:
  type: object
  properties:
   email:
    type: string
   password:
    type: string
 Token:
  type: object
  properties:
   token:
    type: string
 Error:
  type: object
  properties:
   message:
    type: string
   error:
    type: string
 User:
    type: object
    properties:
     email:
      type: string
     password:
      type: string
     firstName:
      type: string
     lastName:
      type: string
     lastLogin:
      type: string
      format: date

Now you just described that the /users route need the Bearer authentication …

Use Swagger UI

In order to use the Swagger UI, you should be aware that the host value is defined on '127.0.0.1:4000' and this may be changed in your case !

First Login and get the token

The now you can use the Swagger UI (with the editor) to login :

And the response should be :

Authenticate the editor :

Now at the top of the generated documentation you can click the Authenticate Button :

Then fill with the Token you received at the previous step :

We are spcifying the Bearer: keyword.

Try the protected route

Now in the section of the protected route : /users you can check the Bearer checkbox and try the operation :

You should have a valid answer :

Now you can add your other routes to finish defined your API.

Have fun !

How to use events in Node.js

mimiz33 — Mon, 28 Nov 2016 00:00:00 GMT

In this blog post I will explain how to create and use Events in Node.Js The main purpose is to demonstrate the following :

I have a module (a) that will do some operations, and I want that module to emit an event when some operations are done. Then I would like other modules (such as b module) to be able to subscribe to those operations.

In order to solve this I will create an EventManager object based on node events.

Create the files :

a.js

var operations = {
  add:function(){
    // operation for add
  },
  remove:function(){
    // operation for remove
  },
  update:function(){
    // operation for update
  }
}
module.exports = operations;

b.js

var b = {
  someCodeWhenAddInA:function(){
    // this function should be executed after a.add is executed
  }
}
module.exports = b;

So the purpose is more than simple, when a.add is called, we want the function b.someCodeWhenAddInA to be called, and we also want to easylly add the ability to add modules that will execute code on a.add called.

Let’s create the EventManager.

EventManager.js

var util         = require("util");
var EventEmitter = require("events").EventEmitter;
function EventManager(){
    EventEmitter.call(this);
}

util.inherits(EventManager, EventEmitter);

module.exports = new EventManager();

refer to the documentation to know more about node js events

Edit the code in a and b modules :

a.js

var EventManager = require('./EventManager');
var operations = {
  add:function(){
    // operation for add
    EventManager.emit('addedToA');
  },
  remove:function(){
    // operation for remove
  },
  update:function(){
    // operation for update
  }
}
module.exports = operations;

b.js

var EventManager = require('./EventManager');
var b = {
  someCodeWhenAddInA:function(){
    // this function should be executed after a.add is executed
    console.log('someCodeWhenAddInA has been executed in b');
  }
}
EventManager.on('addedToA', b.someCodeWhenAddInA);
module.exports = b;

And now let’s simply create a runner file to try our code

main.js

var a = require('./a');
var b = require('./b');

a.add();

This should print someCodeWhenAddInA has been executed in b in the console.

And that’s all !

Now if you want to create a c module which will listen to the same event, it’s easy, and no need to edit the a module anymore :

c.js

var EventManager = require('./EventManager');
var c = {
  anotherFonction:function(){
    // this function should be executed after a.add is executed
    console.log('anotherFonction has been executed in c');
  }
}
EventManager.on('addedToA', c.anotherFonction);
module.exports = b;

main.js

var a = require('./a');
var b = require('./b'); (1)
var c = require('./c'); (2)

a.add();

This will print :

someCodeWhenAddInA has been executed in b
anotherFonction has been executed in c

If you inverse the 1 and 2 the log will also be impacted.

Here we are, comments are appreciated

Rémi's Blog

OpenVPN Server in a Docker Container

Jenkins Docker and Gitlab

Create and get the Jenkins key

Add your credentials to jenkins

Add your key to Gitlab

Create a jenkins job

Configure docker httpd image

Extract httpd.conf

Configure apache and vhosts

Create Docker Container

Node.JS "Require" plays hide-and-seek

The situation …​

Why

Reflections on solutions to have the desired behaviour

The Const way …​ FAIL

The delete way …​ SUCCESS

The Proxy Way …​ SUCCESS

The Clone Way …​ SUCCESS

The decache way …​ SUCCESS

The import Way (aka. the ES6 way) …​ FAIL

Conclusion

Debian Install Node.JS globally with NVM

Install some usefull packages

Install nvm as "root" / superuser

As user

Install some global packages

Use Authorization Header with Swagger

Start the Documentation and the /login route

Describe the Security Definition

Create a protected route

Use Swagger UI

First Login and get the token

Authenticate the editor :

Try the protected route

How to use events in Node.js

The situation …

The Const way … FAIL

The delete way … SUCCESS

The Proxy Way … SUCCESS

The Clone Way … SUCCESS

The decache way … SUCCESS

The import Way (aka. the ES6 way) … FAIL