In this post, we will walk through deploying hyper63 on is a cloud service that is built on top of kubernetes. The service abstracts all of the cloud configuration management challenges and gives you a clean application deployment platform. You can deploy static sites, app servers, cron jobs and private services. Render gives you the ability to setup private networks specified by teams and gives you all the great features of containers and the management of containers leveraging infrastructure as code markup and git repositories.


Before we get started, you may want to signup for an account with render,

NOTE: this tutorial is going to walk through setting up a service using render services that will cost money to host. If you want to check out "hyper63" for free go to and use our playground service.

Setting up the hyper63 config

hyper63 is a modular system, which means you have to specify all of the adapters you want to use with hyper63 via a configuration file. While this may seem to be tedious, it gives you flexibility and extensibility. For our configuration, we are going to use the following services:

  • CouchDb for data port
  • Redis for cache port
  • ElasticSearch for search port
  • MinIO for storage port

Create a new folder called hyper63-micro

mkdir hyper63-micro
cd hyper63-micro

Initialize the project as a NodeJS project, using yarn

npm install --global yarn@1.x
yarn init -y


Install the hyper63 modules:

yarn add @hyper63/core
yarn add @hyper63/app-express
yarn add @hyper63/adapter-couchdb
yarn add @hyper63/adapter-redis
yarn add @hyper63/adapter-minio
yarn add @hyper63/adapter-elasticsearch

Modify the package.json to support ESM modules

  "type": "module"

Create an index.js file to start the service.

import config from './hyper63.config.js'
import hyper63 from '@hyper63/core'


Create the hyper63 config file

import express from '@hyper63/app-express'
import couchdb from '@hyper63/adapter-couchdb'
import redis from '@hyper63/adapter-redis'
import es from '@hyper63/adapter-elasticsearch'
import minio from '@hyper63/adapter-minio'
import jwt from './jwt.js'

const COUCH = `http://${process.env.USER}:${process.env.PASSWORD}@${process.env.COUCHDB_HOST}:5984`
const REDIS = `redis://${process.env.REDIS_HOST}`
const ES = `http://${process.env.SEARCH_HOST}:9200`
const MINIO = `http://${process.env.USER}:${process.env.PASSWORD}@${process.env.MINIO_HOST}:9000`

export default {
  app: express,
  adapters: [
    { port: 'data', plugins: [couchdb({url: COUCH })]},
    { port: 'cache', plugins: [redis({url: REDIS})]},
    { port: 'search', plugins: [es({url: ES})]},
    { port: 'storage', plugins: [minio({url: MINIO})]}
  middleware: [jwt]

We will use jwt middleware to secure our service.

Install express-jwt

yarn add express-jwt

create jwt.js file

import jwt from 'express-jwt'

export default app => {
    secret: process.env.SECRET, 
    algorithms: ['HS256']
  }).unless({path: ['/']}))

  app.use((err, req, res, next) => {
    if ( === 'UnauthorizedError') {
      res.status(401).send({ok: false, msg: 'not authorized'})

  return app

Couchdb Service

In order to create a couchdb service we need to create a docker file.

make a directory called couchdb and in that directory create a file called Dockerfile

mkdir couchdb
touch couchdb/Dockerfile

edit couchdb/Dockerfile

FROM couchdb:3.1.1

RUN echo '[couchdb]' > /opt/couchdb/etc/local.d/10-single-node.ini
RUN echo 'single_node=true' >> /opt/couchdb/etc/local.d/10-single-node.ini

ElasticSearch Service

In order to create an elasticsearch service we need a dockerfile.

make a directory called elastic and in that directory create a file called Dockerfile

mkdir elastic
touch elastic/Dockerfile

edit elastic/Dockerfile

# The official Elasticsearch Docker image
FROM elasticsearch:7.9.3 
# Copy our config file over
COPY --chown=1000:0 config/elasticsearch.yml /usr/share/elasticsearch/config/elasticsearch.yml

# Allow Elasticsearch to create `elasticsearch.keystore`
# to circumvent
RUN chmod g+ws /usr/share/elasticsearch/config

USER 1000:0

create a sub folder called config and a file called elasticsearch.yml

mkdir elastic/config
touch elastic/config/elasticsearch.yml

edit elastic/config/elasticsearch.yml "elastic"
# bind to all network interfaces


create a folder called redis and a Dockerfile

mkdir redis
touch redis/Dockerfile

edit redis/Dockerfile

FROM redis:6-alpine

COPY redis.conf .

ENTRYPOINT ["redis-server", "./redis.conf"]

create another file called redis/redis.conf

You can copy the redis.conf from here:


create a folder called minio and a Dockerfile

mkdir minio
touch minio/Dockerfile

edit minio/Dockerfile

FROM minio/minio:RELEASE.2021-02-14T04-01-33Z

ENTRYPOINT ["minio", "server", "/data"]


create a file called render.yaml

We need to add all of these services to the render.yaml which will instruct render on how to deploy and connect our services in a private render team.

- type: web
  name: hyper63
  env: node
  buildCommand: yarn
  startCommand: yarn start
    - key: SECRET
      generateValue: true
    - key: USER
        name: couchdb
        type: pserv
        envVarKey: COUCHDB_USER
    - key: PASSWORD
        name: couchdb
        type: pserv
        envVarKey: COUCHDB_PASSWORD
    - key: COUCHDB_HOST
        name: couchdb
        type: pserv
        property: host
    - key: REDIS_HOST
        name: redis
        type: pserv
        property: hostport
    - key: SEARCH_HOST
        name: elasticsearch
        type: pserv
        property: host
    - key: MINIO_HOST
        name: minio
        type: pserv
        property: host
- type: pserv
  name: couchdb
  env: docker
  plan: standard
  dockerfilePath: ./couchdb/Dockerfile
    name: couchdata
    mountPath: /opt/couchdb/data
    sizeGB: 50
  autoDeploy: false
    - key: COUCHDB_USER
      value: admin
      value: password
- type: pserv
  name: redis
  env: docker
  dockerfilePath: ./redis/Dockerfile
  dockerContext: ./redis
  plan: standard
  autoDeploy: false
    name: redisdata
    mountPath: /var/lib/redis
    sizeGB: 10
- type: pserv
  name: elasticsearch
  env: docker
  plan: standard
  dockerfilePath: ./elastic/Dockerfile
  dockerContext: ./elastic
    name: esdata
    mountPath: /usr/share/elasticsearch/data
    sizeGB: 10
  autoDeploy: false
    - key: ES_JAVA_OPTS
      value: "-Xms512m -Xmx5123m"
    - key: discovery.type
      value: single-node
    - key:
      value: elastic
- type: pserv
  name: minio
  env: docker
  plan: standard
  dockerfilePath: ./minio/Dockerfile
  dockerContext: ./minio
    name: miniodata
    mountPath: /data
    sizeGB: 20
  autoDeploy: false
      value: admin
      value: password

Add Readme


This is a template repository for running hyper63 on render.

* It uses [Render Disks]( for persistent storage.
* hyper63 runs in your [Render private network]( so it isn't exposed to the public internet.

## Deployment

[![Deploy to Render](](

## Environment

When deployed, go to Environment and grap the SECRET value, this secret will be used to validate JWT Tokens for 
the service.

> NOTE: this deployment plan will create 5 services on render, 4 will cost $15/mo and 1 will cost $7/mo.

Create Repository on Github

git init
echo node_modules > .gitignore
git add .
git commit -m "first commit"
gh repo create hyper63-micro
git push origin master

Sync to Render

In Github, go to the readme view and click the deploy to render button, then in Render, choose this repository and follow the instructions.


This post documents the steps to deploy a micro stack of hyper63, but if you don't want to go through all of this, you can choose to use

Maybe fork the repo and update each docker file with the latest container versions then deploy.