DEV Community: Chirill Ceban

Deploy Ghost using Dokku

Chirill Ceban — Fri, 03 Jun 2022 09:53:10 +0000

I started using Ghost as a headless cms for my personal website and it works like a charm, but I had to spend some time to try and deploy it using Dokku, that's what I am going to write about.

Dokku, oh, it is my favorite self-hosted deployment software for personal and sometimes commercial needs. It has its flaws but overall it works in most situations and allows me to save some money, so I use it for my pet-projects and for my website too.

Before we start, I assume you've already installed Dokku on your server, configured all the things properly, installed dokku-mysql, created a new database (ex: ghost-db), created a new app for Ghost, let's call it simply ghost and linked them.

As of v0.24.0 Dokku allows to deploy Docker images using a straightforward command, before this it was a nightmare with tagging.

dokku git:from-image node-js-app dokku/node-js-getting-started:latest

So, dokku git:from-image is exactly what we need.

Step 1. Deploy Ghost image

We are going to use Docker Ghost image that can be found here. You can use any of the tags, but it is fine to use :latest for initial deployment.

dokku git:from-image ghost ghost:latest

This will build your app using the image you provided and then deploy it using your Dokku settings. By the end of the process you will have a working Ghost instance without any persistance and wrong public ports.

Step 2. Dealing with ports

Here we are going to make Ghost app public by adding some new ports and removing those that we don't need.

dokku proxy:ports-add ghost http:80:2368
dokku proxy:ports-remove ghost http:2368:2368

By the end of this step your Ghost app should now be accessible via a domain you provided initially to Dokku or via port mapping.

Step 3. Persist it

Docker images do not keep any data between restarts, that's why we should provide some persistant volumes to it. Dokku allows us to do this easily via storage:mount command.

dokku storage:ensure-directory ghost
dokku storage:mount /var/lib/dokku/data/storage/ghost:/var/lib/ghost/content
dokku ps:rebuild ghost

In this step we create a new folder ghost in a special place where Dokku docs suggests us to keep persisted data, then we use our new folder /var/lib/dokku/data/storage/ghost to keep Ghost data from docker image folder /var/lib/ghost/content. This way everything that Ghost creates and keeps in this content folder will be persisted between reloads.

Step 4. Database

Ghost can work even without a separate database, using a SQLite and keeping it on the disk, I don't really like it but if you are okay with this, then skip this step. Before we even started, you already installed dokku-mysql and created a database for Ghost, we will need it here.

dokku config:set \
    database__client=mysql \
    database__connection__database=<YOUR_DATABASE_NAME> \
    database__connection__host=<YOUR_DATABASE_HOST> \
    database__connection__password=<YOUR_DATABASE_PASSWORD> \
    database__connection__port=<YOUR_DATABASE_PORT> \
    database__connection__user=mysql

In this step we provide some essential database configuration params to the Ghost app, as you set them, Dokku will restart it and it should then work using mysql database.

Step 5. Domain

One of the main things we should do, is to add a domain to our app, Dokku has some useful commands for this.

dokku domains:add ghost my.ghost.website
dokku config:set ghost url=http://my.ghost.website

Step 6. SSL certificate

You need SSL certificate for your website. With Dokku you can add it in several ways, using official Let's Encypt plugin, or using your own certificate, or using a Cloudflare SSL. Any of these do, but don't neglect this step.

Just don't forget to change your website url in configs.

dokku config:set ghost url=https://my.ghost.website

That's it, by now you have a working website powered by Ghost and deployed using Dokku on your own server for little to no money 🪄🦄✨.

Over-engineering madness or hype-driven development in JS

Chirill Ceban — Tue, 18 Jan 2022 10:23:33 +0000

Let's start with a question, how would you create a website that should just display a logo and some info?

If you have in mind something like Next.js, Nuxt.js, Svelte or any other framework, maybe with a little bit of CSS-in-JS or SASS, or maybe Redux, or even Angular, then you are definitely over-engineering.

I'm not saying that either of these tools are bad or you should not use it, I'd say that they are great, but only when used properly in a proper situation.

So what I am talking about?

Hype-driven development

JavaScript is one of the most popular programming languages in the world, #7 currently and this is awesome, you don't even need to install something special to work with it, just launch you favorite browser and you are good to go.

This tremendous accessibility allows millions of developers to start out their carier with it, we even have probably the biggest package registry in the world - NPM, with stunning 1.8 million packages, isn't it awesome? Sure, it is!

You can now use javascript literally everywhere, you can build backends, mobile apps, program micro-controllers and even launch something into the space. There are thousands of amazing libraries and packages in the eco-system, even more, companies that built some of the most popular tools truly fight for your attention.

And all of this brings us to a question, how to navigate and pick the right tool, how to choose wisely which framework is worth using and when to use it?

If you are a junior developer I bet you use something like React or Vue, Redux or Mobx, and it is not bad, but do you understand why you are using it? Or you followed the hype?

You may even find googling some 'amazing' packages like is-string with 20M downloads, or is-date-object with 21M downloads, or is-boolean-object with 17M downloads and my favorite is-odd with 400K downloads, and use it because so many people cannot be wrong.

Hype, is the problem, hype and github stars rule here, they create unnecessary FOMO feeling that is not a constructive one.

Hype leads to over-engineering when you pick a tool just because it is popular and has 50K, 100K, 200K stars on GitHub, or it was promoted by your favorite dev-blogger or a twitter thread.

Hope you got the idea.

Responsible development

The hype problem is a real one, I know I sound like an old fart, like I'm against new approaches and new ideas, not at all. I think that every tool has its use, but it becomes harder and harder to pick the right one for the job.

And the only real way to deal with it is responsible development, like responsible consumption, but development. A great example of this approach is Redux, that clearly states on the website: "You'll know when you need Flux/Redux. If you aren't sure if you need it, you don't need it.".

As per companies that build tools, they should take the responsability and clearly explain on when you may need their library or tech, like FaaS or edge-computing, on why you may not need it and what are the benefits or disadvantages.

Before using anything try to find a second opinion and try not to use a tool only because it is marketed well. When you use something that is popular right now, you may lead the company you work for to increased costs for development and support in the future. And the best way to check something new is to create a pet project.

I usually tend to run a mind exercise and ask myself several questions before using any library:

Do I really understand it? Like really, if I feel it works like a magicbox, I will try to research and clear my gaps in knowledge.
What are the benefits, disadvantages and consequences? This one stems from the first one.
Will it make something better for me or for the company mid term, long term? Like speed of development, ease of support, ease of hiring other developers, costs and etc. etc.

Answers to these three question help me decide whenever I should use GraphQL for my personal blog or not or should I use a super hyped JAM-stack framework for a clients' project or just stick with something more reliable like AdonisJS, Laravel or Ruby on Rails.

Deploy your Node.js app without a hassle

Chirill Ceban — Sun, 11 Jul 2021 13:10:23 +0000

The process of app deployment takes some time, you have to configure the server, find all the information and be ready to handle the issues, but there is an easier way.

This guide is relevant literally for any app, for Ruby and Rails, for Python and Django, for PHP and Laravel, for Go and micro-services, you can deploy easily anything, but I will use Adonis.js as an example.

I guess any developer knows what is Heroku, they've been de facto a standard of Platform-as-a-Service and showed the world how an app deployment should really work, easily and fast, requiring zero configuration for most cases.

Heroku is not a cheap service, their prices are pretty high and aren't great for pet projects or small services with zero revenue.

There are some cheaper alternatives like Render, Railway or Digital Ocean App platform, but there is a self-hosted solution that works almost like Heroku and is free of charge, you only have to bring your own server.

Dokku

Dokku is the smallest PaaS implementation that allows you to build, manage and deploy your apps on your own server, that may cost you as little as $3.50 per month( I use and recommend Hetzner Cloud, it is a referral link that will give you €20 in credit).

It uses heroku buildpacks and is able to deploy your app using dockerfile as well, it configures nginx as a proxy server, you can install databases and connect them to your app, you can install Let's Encrypt for SSL certificates, you can deploy monorepos, you can mount local storage, there are multiple plugins that handle most use cases and require almost zero configuration.

To install Dokku, you have to allocate a server from you favorite provider, with a minimum requirement of 1 core and 1GB of RAM, then login into your new shiny server and run two commands:

# for latest tag check Dokku git repo
# or https://dokku.com website

wget https://raw.githubusercontent.com/dokku/dokku/v0.24.10/bootstrap.sh
sudo DOKKU_TAG=v0.24.10 bash bootstrap.sh

Then go to your server's IP and follow the web installer process.

Now you have a working self-hosted PaaS that is ready to build and deploy your code.

Deploying an app

As I am using Adonis.js for this guide, I initiate a new app, a web starter template:

npm init adonis-ts-app@latest hello-world

# If using yarn
yarn create adonis-ts-app hello-world

Then we have to initiate git repository for this app:

cd hello-world

# initiate git
git init

# stage all files
git add .

# create first commit
git commit -m 'Init commit'

# add Dokku server as a remote
git remote add dokku dokku@<YOUR_SERVER_IP_ADDRESS_OR_DOMAIN>:hello-world

The part hello-world in git remote address corresponds to a server app name that we should create on the server:

# on the Dokku host
dokku apps:create hello-world
-----> Creating hello-world...

For Adonis.js to start we have to set some environment variables, Dokku provides an easy to use command for this:

# on your computer
# inside project folder
node ace generate:key
> iGyX0deixdW7DkdJ9G9PbyyT8QaizXuK

# on the Dokku host
dokku config:set hello-world \
  HOST=0.0.0.0 \
  APP_KEY=iGyX0deixdW7DkdJ9G9PbyyT8QaizXuK \
  APP_NAME='Hello World' \
  CACHE_VIEWS=true \
  SESSION_DRIVER=cookie

Just before the deploy it is a good idea to create a Procfile and describe how our PaaS should start our app, this file is a very common configurational file, read more about it here. Don't forget to commit it to the repo.

web: node build/server.js

Now we are ready to deploy our app for the first time:

git push dokku master

After a successful deployment Dokku will print you the address where you can access your app, if you chose port based deployments, your address will look like http://<YOUR_SERVER_IP_ADDRESS>:<PORT>, if you chose hostname based deployments, it will look like this: http://<APP_NAME>.<YOUR_SERVER_DOMAIN>. You can add a domain to the app later if needed.

Adding database

Dokku supports multiple databases, MySQL, PostgreSQL, MongoDB, Redis and others.
Here I will install PostgreSQL and then link it to my app:

# on the Dokku host
# install the postgres plugin
# plugin installation requires root, hence the user change
sudo dokku plugin:install https://github.com/dokku/dokku-postgres.git

# create a postgres service
dokku postgres:create hello-world-database

# on the Dokku host
# each official datastore offers a `link` method to link a service to any application
dokku postgres:link hello-world-database hello-world

Linking adds a new environment variable to the app, DATABASE_URL that is a database connection string with all the credentials we need.

For Adonis.js to work with database we should install Lucid ORM and configure it properly.

npm install @adonisjs/lucid@latest
# or
yarn add @adonisjs/lucid

# and then
node ace configure @adonisjs/lucid

After installation don't forget to add new database environment variables to Dokku, you can use DATABASE_URL that was provided before or split it to separated values, connection string url follows a well known format, so it is not a problem to identify credentials and host address.

To run database migrations on each deploy we should update our Procfile by adding new values:

web: node build/server.js
release: node build/ace migration:run --force

Commit new updates and run a deploy again!

git push dokku master

Encrypting connection

Dokku is built on top of plugins. One of them uses Let's Encrypt to provide SSL certificates to Nginx proxy server.

Installing the plugin is as simple as running a command:

# on Dokku host
sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git

To encrypt the connection of your app run dokku letsencrypt hello-world and then dokku letsencrypt:cron-job --add to add a crontab job that will renew certificates when needed.

That's it, your app is now served using SSL!

Conclusion

Dokku is a great Heroku-like tool for build and deploy automation, it is universal and can be used almost by any company. It does not support clustering and brings some Docker problems with it, but well, if you need clustering for your app and have that many requests per second, then you may also have money for Heroku or others, or even your personal DevOps engineer.

You may read more about dokku command and possibilities on their website.

Migrate AdonisJS v4 user passwords to v5

Chirill Ceban — Tue, 06 Jul 2021 16:15:10 +0000

A new version of Adonis.js isn't just a simple update, it is a complete revamp of all the core modules and structure including hashing mechanism.

Prior the update Adonis.js used plain bcrypt hashing implementation but now it became more standartized, the use of PHC string format allows to incorporate different hashers and verify the hashes against the current configuration and then decide if the hash needs to be rehashed or not.

This change leads to a situation when old v4 hashes will not be compatible with v5 and your users will not be able to login.

The way to resolve this problem I'd describe in three steps:

Expand hasher with our own legacy driver
On user authentication attempt check if the password has been hashed using an old hasher, if yes, use our new legacy driver
Authenticate user and rehash password using a new hasher, in my case I'm using argon2

Expanding the hasher

To expand the hasher we have to create a new local provider by running a corresponding command inside our projects folder:

node ace make:provider LegacyHasher

This will generate a new provider file inside /providers folder. After the file has been generated, we have to add it to .adonisrc.json into providers section.

Before actually expending we have to create a new Hash driver, as an example we can use the code provided in an official documentation here.

I created a separate folder inside /providers, named it LegacyHashDriver and placed my legacy driver there (inside an index.ts file).

import bcrypt from 'bcrypt';
import { HashDriverContract } from '@ioc:Adonis/Core/Hash';
/**
 * Implementation of custom bcrypt driver
 */
export class LegacyHashDriver implements HashDriverContract {
  /**
   * Hash value
   */
  public async make(value: string) {
    return bcrypt.hash(value);
  }
  /**
   * Verify value
   */
  public async verify(hashedValue: string, plainValue: string) {
    return bcrypt.compare(plainValue, hashedValue);
  }
}

As you can see, it depends on a bcrypt package, you'll have to install it before running.

Having created a new driver, we can now expand the Hash core library.

import { ApplicationContract } from '@ioc:Adonis/Core/Application';
import { LegacyHashDriver } from './LegacyHashDriver';

export default class LegacyHasherProvider {
  constructor(protected app: ApplicationContract) {}

  public async boot() {
    const Hash = this.app.container.use('Adonis/Core/Hash');

    Hash.extend('legacy', () => {
      return new LegacyHashDriver();
    });
  }
}

There are two additional things we have to do before proceeding to actual testing of implementation. We have to add our new hasher to contracts/hash.ts:

declare module '@ioc:Adonis/Core/Hash' {
  interface HashersList {
    bcrypt: {
      config: BcryptConfig;
      implementation: BcryptContract;
    };
    argon: {
      config: ArgonConfig;
      implementation: ArgonContract;
    };
    legacy: {
      config: {};
      implementation: HashDriverContract;
    };
  }
}

And add it to config/hash.ts:

...
  legacy: {
    driver: 'legacy',
  },
...

Authenticating users with legacy hasher

As user tries to login the first thing you do (after request validation) is user search, by email or username. When you find a corresponding record, you can check if the password hash has been generated using an old method, by testing it
agains a simple regex. Then later verify it using the right hash driver.

const usesLegacyHasher = /^\$2[aby]/.test(user.password);
let isMatchedPassword = false;

if (usesLegacyHasher) {
  isMatchedPassword = await Hash.use('legacy').verify(user.password, password);
} else {
  isMatchedPassword = await Hash.verify(user.password, password);
}

Rehashing old user password

Rehashing user password on login is the most convenient way to migrate to a new driver. I do this after I checked all the security things, found the user and know that the password is hashed using an old method.

try {
  const token = await auth.use('api').generate(user);

  // rehash user password
  if (usesLegacyHasher) {
    user.password = await Hash.make(password);
    await user.save();
  }

  return response.ok({
    message: 'ok',
    user,
    token,
  });
} catch (e) {
  return response.internalServerError({ message: e.message });
}

Now you can test it and it should work. You can expand hasher not only to migrate from v4 to v5, but even when you try to build your app on top of existing database.

5 things I learned while freelancing

Chirill Ceban — Mon, 14 Jun 2021 08:07:11 +0000

Freelancers or independent contractors are in demand as never have been before, the pandemic changed how businesses work and hiring a remote worker has become a new normal.

As a freelancer myself with years and years of remote work experience and sometimes as a client who hires for work, I decided to share some ideas and advices with those who just start or want to improve their experience and success rate.

Be a human and read carefully

From times to times I had to hire some professionals and this experience allowed me to understand how a client feels like when receives proposals.

First of all I should say that more than 95% of freelancers just don't read job descriptions, they copy paste a prepared "promotional" text and send it.

Don't do like this, ever.

This does not work and shows that you are not really interested, most of the times this makes the client remove your proposal and proceed with somebody else who reads the description, answers the questions, asks some questions and is proactive.

Learn to discuss and convince

The ability to discuss and convince somebody using structured arguments is very important.

You should not always agree with a client, your main goal should be a good product and you as a professional hired to do your job should be able to propose some ideas and help the client choose the best option.

So, next time you'll do something, just propose some ideas and changes backing them up with good reasoning, with some examples and etc. Trust me, this will give you a lot of credit and possibly your client will share you contact with someone else.

Leave traces of agreements

Leaving traces of agreements is important and how many times I've seen people ignore this, to be honest I ignored this too to the moment when a client just scammed me and left me without money. Freelancers do scam clients too, so this matches both sides.

What does it actually mean, leaving traces of agreements?

First of all, you should communicate on a platform where you got your job, usually the platforms act as an escrow, protecting your agreements and money, of course they take percentage for this, but what is better, to get your money or
product, or be scammed and not pay for escrow?

If you got your job or hired a worker somewhere else, sign a contract, there are multiple good examples on the internet.

Talk and discuss using messengers where no one can edit their messages or via email, that is even better, as emails are usually considered first class proof of agreement in courts, but don't forget to mention email addresses in the contact.

Never say a hard no

I consider that saying a hard no is a pretty bad business approach when working for yourself.

Even when you don't want to work with a client who asks for your help, just don't say no, say that you are busy and will be free in three months for example, or name a price that is reasonably high for this client, just don't say no.

As you never know what will happen in the future and you don't what to burn all the bridges behind.

Do project for yourself

Make imaginary projects for yourself or solve your problems with your own skillsets. This is really important, as it allows you to use a new tool, develop a new skill, check design trends or update portfolio.

Maybe help your friends or someone who cannot afford your services. What is more important, this will help you understand how the projects are done, from planning to mockups, from idea and research to launch.

Doing something for yourself is hard, this needs a very specific motivation boost, but this will help you in the future and will teach you something anyway.

Through Sails and Rails to Adonis.js

Chirill Ceban — Thu, 10 Sep 2020 06:20:57 +0000

Even though Node.js has been around since 2009, 11 years so far, the web framework options are still very limited, basically you have two main paths:

To choose Express.js and then build something kinda reliable on top of it by yourself
To choose something based on top of Express.js and built by somebody else

Combine it again and again 🤯

To be honest I am not fan of the first path, if not say more, you have to combine multiple packages, choose template language, ORM, think about error handling, logging, folder structure, body parser, security, authentication, authorization, validation and many many other little aspects that are not really cool to deal with, basically you waste your developer time to a battle that may not be won. I tried this way, It blew my mind, I did not like it.

High hopes 🤞

The second path is the path I tried multiple times. Sails.js was my hope at that time, being based on express.js it was pretty promising, but no luck. Then Feathers, LoopBack, Kraken, Keystone - no luck, all these tools were just okay really, nothing that may be compared to Ruby on Rails or Laravel.

A revelation 🤔

It was 2014 outside, I lost my hope and started digging Ruby on Rails to finally stop and find something production ready, a developer heaven. That was a revelation of how a framework and an ecosystem around it should work and should be built.

While still working with Rails full-time I was looking for something new in Node.js web-frameworks world that may catch my eye and make me somehow try it. I've been googling here and there and then finally found something new that was really different - Adonis.js.

Adonis.js - the god of beauty on a Node.js Olympus ⛰️

Adonis is built with developer happiness in mind, inspired by Laravel and Rails, very structured and opinionated from the very beginning, the new v5 uses Typescript everywhere (but you still can use plain JavaScript).

It is created from the ground up by a very talented engineer Harminder Virk, has a nice and vibrant community and multiple packages that extend possibilities even more.

Basically, Adonis is an integrated system, and it serves you well in a myriad of situation. You'd like to create an API, no problem, just don't install views and then serve JSON directly, you'd like to serve views, no problem it has its own Edge temple engine, a very advanced one, you'd like to use PostgreSQL or MySQL or combine them, no problem, it has it's own Lucid ORM based on top of Knex.js and typed through out, it has validations, security, caching, routing, folder structure, service providers and many many other little things that will definitely make you happier. Using Adonis you don't have to spend hours and hours combining things, you take your idea on paper and implement it in a flawless way.

I used Adonis for some of my pet and commercial project that I built for the last 3 years, it had it's own problems and caveats but the way it improves and develops makes me confident about its future.

You may learn more about it here adonisjs.com, here Github Discussions and here @adonisjs.