Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Docker.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Docker?

Docker is a software technology providing containers, promoted by the company Docker, Inc.

I am assuming everone know what it is so I won't go in further explanations. That being said, if you are familiar with Clever Cloud, you may know we have a reputation of not being big fans of Docker. Yet you can deploy Docker containers on Clever Cloud and we were actually one of the first cloud to offer it.

We do like Docker but as a public cloud we have to isolate each containers in a VM for proper isolation. We have to have an absolute position when it comes to security. Anyway, please let us know in the comments if you want us to talk more about our position on Docker and containers. We plan to do a lot more on that side, we just need a bit more time to release it to the public :)

So why talking about Docker today? Well it turns out some of our users asked us if it was possible to deploy Keycloak on Clever Cloud. So I looked into it. There are various way to deploy it. The first way I wanted to use was to deploy it as a Wildfly overlay using their .war.

But sadly it's not recommended in production. You have to use their full wildfly distribution. So I could either download the whole thing each time I start the application, or deploy the Docker container they offer and support in Production. Which is what I have chosen.

Setup

Keycloak Docker images are all available on Github. And has you need to provide a Dockerfile in your source code for us to build, I copied the official one for the HA/PosgreSQL configuration. I would have gladly forked the repo but it contains all their images. Not very 12 factors compliant sadly :( Anyway my git repository looks like this:

[ldoguin@caolila keycloakClever]$ ls
Dockerfile

and the Dockerfile like this:

FROM jboss/keycloak-postgres:3.4.0.Final

CMD ["-b", "0.0.0.0", "--server-config", "standalone-ha.xml"]

We don't have anything specific to add to this Dockerfile. It's very well configured and easy to use. We now need to create the Clever Cloud application and its associated database then setup the right environmment variables:

• Create our application: clever create --type docker --plan M Keycloak
• Create our Postgres add-on: clever addon create postgresql-addon --plan dev --region eu KeycloakPG
• Link this website to our FS Bucket addon: clever service link-addon KeycloakPG
• Setup the following environment variables:

clever env set ENABLE_METRICS true
clever env set PROXY_ADDRESS_FORWARDING true
clever env set KEYCLOAK_PASSWORD admin
clever env set KEYCLOAK_USER admin
clever env set JAVA_OPTS "-Djgroups.bind_addr=127.0.0.1"
clever env set POSTGRES_DATABASE `clever env | awk  -F = '/POSTGRESQL_ADDON_DB/ { print $2}'
clever env set POSTGRES_PASSWORD `clever env | awk  -F = '/POSTGRESQL_ADDON_PASSWORD/ { print $2}'
clever env set POSTGRES_PORT_5432_TCP_ADDR `clever env | awk  -F = '/POSTGRESQL_ADDON_HOST/ { print $2}'
clever env set POSTGRES_PORT_5432_TCP_PORT `clever env | awk  -F = '/POSTGRESQL_ADDON_PORT/ { print $2}'
clever env set POSTGRES_USER `clever env | awk  -F = '/POSTGRESQL_ADDON_USER/ { print $2}'

Before starting the build, we need to configure two options in the Console. Tick the Enable dedicated build instance box because the Keycloak build needs more memory. Also tick the Sticky sessions box because it is necessary if you need to scale horizontally. To do that you have to go on the WebConsole, in your application, in the Information tab and tick the previously mentioned checkboxs.

You should now be ready to deploy :)

Deploy

Deploying with Clever Cloud is the easiest part. Simply run clever deploy and see the logs unfold before your eyes. Go ahead and test it by running clever open. Make sure you are using https while browsing the site. The default login and password are the one you set in the environment variable.

Now everything should work smoothly. What if you need to scale out your application? Let's say you want to have 2 keycloak instances. This can be configured like this:clever scale --instances 2

If you are unsure of the traffic you will get, you can configure a minimum and a maximum of instaces like this: clever scale --min-instances 2 --max-instances 5

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about a bunch of interesting technologies: Kotlin, Spring 5 and MongoDB.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Kotlin, Spring 5 and Reactive MongoDB?

This time we get to talk about all these things in one post because of a code sample I found. Someone on twitter asked us if Kotlin code could be deployed on Clever Cloud. The answer is yes. You can deploy anything that can be packaged as a Jar or War. So that means Kotlin, but also Ceylon, Clojure, Groovy, Scala and many more. So what is Kotlin?

Kotlin is a statically-typed programming language that runs on the Java virtual machine and also can be compiled to JavaScript source code or use the LLVM compiler infrastructure.

It's also worth noting that it can target native environment beyond the JVM. So it can be used to write iOS app for instance. This post on multiplatform native developement with Kotlin will give you a better idea of the many things you can do.

Anway I looked for a Kotlin sample online and I found the traditional Pet Clinic sample written in Kotlin with Spring 5 and Reactive MongoDB. Which is nice because Spring 5 is all about being reactive. And Kotlin is a great fit for that because of its Lambdas support. But we are not going to look at the code, we are going to look at how to deploy this Kotlin/MongoDB project on Clever Cloud.

Setup

Here are the steps you need to go through to deploy this application:

• Clone the project: git clone https://github.com/ssouris/petclinic-spring5-reactive
• Get in the project: cd petclinic-spring5-reactive
• Create our PostgreMongoDB add-on: clever addon create mongodb-addon --plan peanut petClinicMongo
• Create our application: clever create --type gradle petClinic
• Link our MongoDb add-on: clever service link-addon petClinicMongo

Setup the necessary environment variables for configuration:

clever env set GRADLE_DEPLOY_GOAL bootRun
clever env set SPRING_DATA_MONGODB_URI `clever env | awk  -F = '/MONGODB_ADDON_URI/ { print $2}'`

Here we start by specifying which Gradle goal to run. This goal compiles and runs the application. Then we configured the MongoDB connection.

Deploy

To deploy your application, run clever deploy then clever open. You should see the logs of your application being ran successfuly then have the website open in your default web browser. And as you can see your Kotlin project is up and running and talking to a MongoDB database the reactive way.

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Meteor.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Meteor.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Meteor?

Meteor is an open source platform for web, mobile, and desktop.

It's also a JavaScript based, cross device stack that uses MongoDB for persistence. They have a great ecosystem with many modules. Search for Meteor on Github and you will get lots and lots of results. I sorted them out by date and it's impressive how active that ecosystem is. One of the most stared project is a Trello clone called Wekan. This is what we are going to deploy today.

Setup

Here are the steps to create and deploy a Wekan application to Clever Cloud:

• Clone the project: git clone https://github.com/wekan/wekan
• Get in the project: cd wekan
• Create the Meteor application: clever create --type meteor wekan
• Create the MongoDB addon: clever addon create mongodb-addon --plan peanut wekanDB
• Link the database to the application: clever service link-addon wekanDB
• Add your domain: clever domain add wekan.cleverapps.io
• Configure the MongoDB connection: clever env set MONGODB_URI `clever env | awk -F = '/MONGODB_ADDON_URI/ { print $2}'`
• Set the root URL of your website: clever env set ROOT_URL https://wekan.cleverapps.io

By default Clever Cloud uses node 8 to build your project but this won't work with Wekan, I am using node 6. To do that you need to edit package.json and add the following content:

"engines": {
    "node": "^6"
}

With that you are ready for a baisc Wekan configuration. You can also setup an email SMTP server if you have one:

clever env set MAIL_URL smtp://user:pass@mailserver.example.com:25/
clever env set MAIL_FROM wekan-admin@example.com

Deploy

To deploy the application first go on Clever Cloud's WebConsole, select your application, select the information tab and tick the Enable dedicated build instance checkbox.

Now run clever deploy and your build should start. Meteor builds can be long, be patient. In 10 minutes you will have your Wekan instance in production :)

If you like Meteor, VulcanJS is an interesting project and can be deployed with the exact same process. I invite you to test other Meteor applications and let us know how it worked!

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about JHipster.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at JHipster.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is JHipster?

JHipster is a development platform to generate, develop and deploy Spring Boot + Angular Web applications and Spring microservices.

JHipster, not your grandma's Yeoman generator, has been around for quite some time now and seems to be one of the default solution to scafold a modern SpringBoot+Angular stack. It supports many different options for both frontend and backend. Some of these supported by Clever Cloud.

So today we are going to deploy a JHipster stack based on MySQL. We are doing this mostly because our good friends Stephan Janssen and Antonio Goncalves told us they would love to see a JHipster/Clever Cloud integration. Before any convenient integration, I need to know how it works :)

Setup

Here are the steps to create and deploy a JHipster/MySQL application to Clever Cloud:

• First make sure you have installed JHipster: yarn global add generator-jhipster
• Create a folder for your future application: mkdir clever-jhipster && cd clever-jhipster
• Run JHipster and follow instructions on screen jhipster
• Make sure you select MySQL and Maven in the wizard
• Create the MySQL database: clever addon create mysql-addon --plan dev --region eu jhipstersql
• Create the Clever Cloud application: clever create --type maven cleverJHipster
• Link your database to your application: clever service link-addon jhipstersql
• Create a clevercloud folder at the root of your project: mkdir clevercloud
• Create a maven.json file with the following content: vim clevercloud/maven.json

{
  "build": {
    "type": "maven",
    "goal": "-Pprod package -DskipTests"
  },
  "deploy": {
    "jarName": "./target/jhipster-0.0.1-SNAPSHOT.war"
  }
}

This file tells Clever Cloud to run mvn -Pprod package -DskipTests and then java -jar ./target/my-app-0.0.1-SNAPSHOT.war. Don't forget to change the jarName according to the name of your project.

Now to configure the application we will create aclevercloud/application-clever.yml file containing all the specific configuration to run on Clever Cloud.

spring:
    datasource:
        url: jdbc:mysql://${MYSQL_ADDON_HOST}:${MYSQL_ADDON_PORT}/${MYSQL_ADDON_DB}?useUnicode=true&characterEncoding=utf8&useSSL=false
        username: ${MYSQL_ADDON_USER}
        password: ${MYSQL_ADDON_PASSWORD}
        maxActive: 5

Here I am using variable already predefined by CleverCloud with the ${} synthax. To make sure this file is found while running the application, we need to copy it right before running with a hook: clever env set CC_PRE_RUN_HOOK "cp ./clevercloud/application-clever.yml ./application-prod.yml"

Deploy

Select the build dedicated instance because the JHipster build is memory greedy. To do that you have to go on the WebConsole, in your application, in the Information tab and tick the Enable dedicated build instance checkbox.

Now commit your changes and run clever deploy, this will push your code to our remote git branch and deploy it. At the end you can type clever open and it should open your website in your default web browser.

We plan to have a better integration to JHipster through a module. What kind of features would you like to have?

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Laravel.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Laravel.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Laravel?

Laravel is a free, open-source PHP web framework, created by Taylor Otwell and intended for the development of web applications following the model–view–controller (MVC) architectural pattern.

To go a bit further the basics, I have deployed this URL shortener application called Polr. It's actualy written with Lumen, a Laravel micro-framework.

Setup

Here are the necessary steps to configure your Polr application:

• Clone the backend: git clone https://github.com/cydrobolt/polr
• Get in the project: cd polr
• Create the PHP application: clever create --type php polr
• Create the MySQL addon: clever addon create mysql-addon --plan dev polr-mysql
• Link the database to the application: clever service link-addon polr-mysql
• Add your domain: clever domain add mypolr.cleverapps.io
• Copy the default configuration: cp .env.setup .env

Then you need to setup the default webroot. We don't support environment variable for this yet, so you will have to create a php.json file under a clevercloud directory:

mkdir clevercloud vim clevercloud/php.json

{
  "deploy": {
    "webroot": "/public"
  }
}

Now commit all your changes, run clever deploy than clever open. You will be taken straight to the setup wizard of Polr. Go through all the steps, yes even the database configuration, because the setup will write ot the DB at the end. It will also overwrite .env. Problem is we use immutable infrastructure so all the changes written on that file will be lost at reboot. And reboot can happen for many reasons. Best way to manage this is to use clever ssh to log on the machine and copy the content of the now changed .env file to your own version of the file.

All the fields in this file can be remove and replaced by environment variables. You can also use pre-existing variables. In my case I have configured the database part like this:

DB_HOST=$MYSQL_ADDON_HOST
DB_PORT=$MYSQL_ADDON_PORT
DB_DATABASE=$MYSQL_ADDON_DB
DB_USERNAME=$MYSQL_ADDON_USER
DB_PASSWORD=$MYSQL_ADDON_PASSWORD

Feel free to remove any fields you want to setup as an environment variable as they will be picked up automatically too.

The other option you have would have been to know exactly all the configuration variables needed, set them all, than ssh on the machine and use the artisan CLI to seed the database. Which is to me more cumbersome.

Whatever solution you choose, take a look at their installation guide. This will give you a good idea of all the things that are managed automatically by Clever Cloud :)

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Vert-x and Golo.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Vert-x and Golo.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Vert-x?

Eclipse Vert.x is a tool-kit for building reactive applications on the JVM.

And when they write JVM, they mean it. You can use any JVM language. Beyond the polyglot statement, you will find out that it's also event driven and non blocking. Which means it's ready to scale and will use your hardware as much as possible. It's reactive. I invite you to read the Reactive Manifesto if you have no idea what it is. Vert-x is unopinionated and as such is a good fit for any kind of application or microservice. Here we will use it to build an API.

What is Golo

A lightweight dynamic language for the JVM.

You can install Golo with a standalone binary available on their website. It's important because today we will also look at how to create a Golo project from scrach instead of using an existing one. All of this is happening thanks to our CSO Philippe Charrière who previously blogged on this subject, check out his blog!

Create a Golo Project

In a terminal, type these commands:

golo new vertx.golo.demo --type maven
cd vertx.golo.demo

The Golo CLI has generated a Golo project:

.
├── pom.xml
├── src
│   └── main
│       └── golo
│           └── main.golo

To make sure you can compile the project, you have to update the pom.xml file: Change the Golo version by replacing

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <golo.version>3.2.0-SNAPSHOT</golo.version>
  </properties>

with:

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <golo.version>3.2.0</golo.version>
    <vertx.version>3.4.1</vertx.version>
  </properties>

Add some dependencies and the bintray repository:

  <dependencies>
    <dependency>
      <groupId>org.eclipse.golo</groupId>
      <artifactId>golo</artifactId>
      <version>${golo.version}</version>
    </dependency>

    <dependency>
      <groupId>com.googlecode.json-simple</groupId>
      <artifactId>json-simple</artifactId>
      <version>1.1.1</version>
    </dependency>

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-core</artifactId>
      <version>${vertx.version}</version>
    </dependency>

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-web</artifactId>
      <version>${vertx.version}</version>
    </dependency>

  </dependencies>

  <repositories>
    <repository>
      <id>bintray</id>
      <name>Bintray</name>
      <url>https://jcenter.bintray.com</url>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>bintray</id>
      <name>Bintray</name>
      <url>https://jcenter.bintray.com</url>
    </pluginRepository>
  </pluginRepositories>

We are going to write a very simple Vert-x web application with Golo. For that, replace the content of /src/main/golo/main.golo with this:

module vertx.golo.demo

import io.vertx.core.Vertx
import io.vertx.core.http.HttpServer
import io.vertx.ext.web.Router
import io.vertx.ext.web.handler

import gololang.JSON

let vertx = Vertx.vertx()

function main = |args| {

  let server = vertx: createHttpServer()
  let router = Router.router(vertx)
  router: route(): handler(BodyHandler.create())

  let port =  Integer.parseInt(System.getenv(): get("PORT") orIfNull "8080")

  router: get("/"): handler(|context| {
    context: response(): putHeader("content-type", "text/html;charset=UTF-8")
    context: response(): end("<h1>Hello 🌍</h1>", "UTF-8")
  })

  router: get("/hi"): handler(|context| {
    context: response(): putHeader("content-type", "application/json;charset=UTF-8")
    context: response(): end(JSON.stringify(DynamicObject(): message("Hi 😛")), "UTF-8")
  })

  server: requestHandler(|httpRequest| -> router: accept(httpRequest)): listen(port)

  println("listening on " + port)
}

To test the application:

• Built it with: mvn package
• Run it with: mvn exec:java
• Test your web application by opening http://localhost:8080 and http://localhost:8080/hi

If it works locally then you are ready for the next step. Set it up for Clever Cloud.

Setup

Clever Cloud can run any JVM code packaged as a .war or .jar. You can either checkout those files directly in your Github repository or have them built with Maven or Gradle. In this case it's a Maven build that generates a .jar file from some Golo code. So when we create the application we have to select maven as type: clever create --type maven vertx-golo-sample

The only configurable thing is the port of the server. It defaults to 8080 in the code. It's also the case for each application running on Clever Cloud as it is required. So nothing to change here, we are ready to deploy.

Deploy

To make our Maven buikd work we need to state which build goal is needed and where is the .jar file to run. To do so create in your project directory a clevercloud directory with a jar.json file containing:

{
  "build": {
    "type": "maven",
    "goal": "package"
  },
  "deploy": {
    "jarName": "target/vertx.golo.demo-0.0.1-SNAPSHOT-jar-with-dependencies.jar"
  }
}

It configures your application to run mvn package then java -jar target/vertx.golo.demo-0.0.1-SNAPSHOT-jar-with-dependencies.jar.

The last step to deploy it is to initiate an empty git repository, add and commit your code, then deploy it:

git init
git add src/ pom.xml clevercloud/
git commit -m "first version"
clever deploy

What clever deploy does is pushing your code to a remote git branch that was created when you created the application in the setup step. Right now you should start seeing build logs in the console. If everything worked well run clever open. It will take you straight to your web application and display Hello 🌍!

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Sinatra.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Sinatra.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Sinatra?

Sinatra is a DSL for quickly creating web applications in Ruby with minimal effort

It's been around for 10 years now and has already inspired several other framework since then. Ratpack which was showcased last week has been heavily inspired by sinatra for instance. Our own Keruspe wanted to play with a couple of Ruby technologies like Puma and Sinatra. And so he built a sample project for it. That's what we are going to deploy today.

Setup

• Start by cloning the sources: git clone https://github.com/CleverCloud/demo-sinatra-puma-activerecord
• Create the database you want to use, in my case Postgres: clever addon create postgresql-addon --plan dev --region eu sinatraPG
• Create the Ruby application on Clever Cloud: clever create --type ruby sinatraSample --region par
• Link the Postgres add-on to the application: clever service link-addon sinatraPG
• Tell Clever Cloud to deploy the API using puma (the default is uwsgi as of now): clever env set CC_RACKUP_SERVER puma
• Tell Clever Cloud to run database migrations before launching the API:clever env set CC_PRE_RUN_HOOK 'bundle exec rake db:migrate'
• Add a domain name: clever domain add mySinatraSample.cleverapps.io

Specify the maximum number of PG connections your application will use (depending on the selected plan) by adding an environment variable like DB_POOL=5 if you want to use 5 connections. For production, you should also set:

clever env set RACK_ENV production
clever env set RAILS_ENV production

Deploy

• Deploy the application with clever deploy

And you are up and running. This application provides an API to store users. They only have a name field. Users can be created with a POST request and retrieve with a GET request like so:

• Create an object with curl --data "regis" https://mySinatraSample.cleverapps.io
• Retrieve that object with curl https://mySinatraSample.cleverapps.io/regis

Everything works out of the box because this application has been written for Clever Cloud. If you take a look at the condfiguration file under ./config/database.yml you should see some environment variables being used. They are the one provided by our Postgres add-on. You can get the full list of variables with clever env.

Let us know your thoughts on this in the comments below. We will be back tomorrow for another post :)

Welcome to this new edition of One Framework a Day keeps the Boredom Away. In this series I will show you how to deploy a particular framework on Clever Cloud every day until I want to go back to boredom. Today it's about Express.

In each post of this series we'll see how to deploy a particular framework on Clever Cloud. Today we are taking a look at Express.

If you want to tag along, make sure you have git, a Clever Cloud account and that you have installed our CLI Clever-Tools.

What is Express?

Fast, unopinionated, minimalist web framework for Node.js

It's pretty much the default JavaScript framework for backend stuff. It's ridiculously simple to use and benefits from a great ecosystem. If you are thinking about a particular module, there's a good chance someone already wrote it. I found a project called RealWorld. They use a Medium clone as example application and have implemented it with a variety of backend and frontend frameworks. Today I will use it as an example with their Express, MondoDB backend and their React,Redux frontend.

Setup

Let's start by the backend. It's a Node.js application using MongoDB so I will need a Node.js application and a MongoDB add-on.

• Clone the backend: git clone https://github.com/gothinkster/node-express-realworld-example-app
• Get in the project: cd node-express-realworld-example-app
• Create the Node.js application: clever create --type node realworld-express
• Create the MongoDB addon: clever addon create mongodb-addon --plan peanut realworld-mongodb
• Link the database to the application: clever service link-addon realworld-mongodb

Great thing about this application is that it's already configurable with environment variable so we just have to set them up:

• Configure the MongoDB connection: clever env set MONGODB_URI `clever env | awk -F = '/MONGODB_ADDON_URI/ { print $2}'`
• Set the production flag: clever env set NODE_ENV production
• Set the secret used by the app: clever env set SECRET myVerySecretiveSecret
• Add a domain name: clever domain add realworldMongoExpress.cleverapps.io

Which make your backend ready to be deployed :)

Moving on to the frontend.

• Clone the frontend: git clone https://github.com/gothinkster/react-redux-realworld-example-app
• Get in the project: cd react-redux-realworld-example-app
• Create the Node.js application: clever create --type node realworld-frontend
• Set the production flag: clever env set NODE_ENV production

Sadly this one requires a little tweaking to use environment variable for configuration. I have edited the file src/agent.js like so:

- const API_ROOT = 'https://conduit.productionready.io/api';
+ const API_ROOT =  process.env.API_ROOT || 'https://conduit.productionready.io/api';

• Now I can configure the backend with clever env set API_ROOT https://realworldMongoExpress.cleverapps.io/api

Don't forget to commit your changes. And now you are ready to deploy :)

Deploy

Since it's a NodeJS application, the rule for deployment is simple. There has to be a main or scripts.start field in package.json. For the backend is ready so all you have to do is run clever deploy. That's it.

For the frontend we have a scripts.start but the PORT variable is hardcoded. So I simply removed it and commited my change:

- "start": "cross-env PORT=4100 react-scripts start",
+ "start": "cross-env react-scripts start",

Now it's ready for deployment. Again running clever deploy is all you need. Run clever open and your Medium clone will open in your default browser.

Is that it? Yes if you are not expecting too much traffic. But maybe you are indeed expecting traffic. Or maybe you don't know. Both situation are fine because Clever Cloud provides automatic scaling. Let's say you want to have 2 VM for the backend. This can be configured like this:clever scale --instances 2

If you are not sure about the frontend, you can setup a minimum of 2 and a maximum of 5 like this: clever scale --min-instances 2 --max-instances 5

That's it. You have deployed a MongoDB/Express backend and a React/Redux frontend in production. And you are ready for high level of traffic :)

What is Ratpack?

• Ratpack is a set of Java libraries for building modern HTTP applications.
• It provides just enough for writing practical, high performance, apps.
• It is built on Java 8, Netty and reactive principles.

Setup

• Create the application: clever create --type gradle ratpackTest --region par
• Link the add-on: clever service link-addon ratpackPG

db:
  username: ${POSTGRESQL_ADDON_USER}
  password: ${POSTGRESQL_ADDON_PASSWORD}
  database: ${POSTGRESQL_ADDON_DB}
  poolSize: 4
  hostname: ${POSTGRESQL_ADDON_HOST}
  port: ${POSTGRESQL_ADDON_PORT}

clever env set RATPACK_PORT 8080
clever env set db_database \${POSTGRESQL_ADDON_DB}
clever env set db_hostname \${POSTGRESQL_ADDON_HOST}
clever env set db_password \${POSTGRESQL_ADDON_PASSWORD}
clever env set db_port \${POSTGRESQL_ADDON_PORT}
clever env set db_username \${POSTGRESQL_ADDON_USER}
clever env set db_poolSize 4

public Observable<Product> getProducts() {
  return pool.queryRows("select * from product").map(row -> {
    Long id = row.getLong("product_id");
    String name = row.getString("name");
    String description = row.getString("description");
    Boolean available = row.getBoolean("is_available");
    BigDecimal price = row.getBigDecimal("price");
    return new Product(id, name, description, available, price);
  }).doOnError(Throwable::printStackTrace);
}

CREATE TABLE public.product (
   product_id   bigint,
   name   text,
   description   text,
   is_available   boolean,
   price   double precision
);
INSERT INTO product(product_id, name, description, is_available, price)
       VALUES (1, 'product name','product description', true, 20.00);

touch data.sql
echo "CREATE TABLE public.product (product_id   bigint,   name   text,   description   text,   is_available   boolean,   price   double precision); INSERT INTO product(product_id, name, description, is_available, price) VALUES (1, 'product name','product description', true, 20.00);" > data.sql

Deploy

{
  "deploy": {
    "goal": "run"
  }
}

git add clevercloud/gradle.json src/main/resources/application.yml
git commit -m"add clever cloud specifics"

What is Ruby on Rails?

Ruby on Rails, or simply Rails, is a server-side web application framework written in Ruby under the MIT License. Rails is a model–view–controller framework, providing default structures for a database, a web service, and web pages.

Setup

• Start by cloning the sources, here I am checking out the latest stable branch: git clone https://github.com/edavis10/redmine/ --branch 3.4-stable
• Create the database you want to use, in my case Postgres: clever addon create postgresql-addon --plan dev --region eu redminePG
• Create a FS Bucket: clever addon create fs-bucket --plan s --region eu redmineFS
• Create the Ruby application on Clever Cloud: clever create --type ruby redmine --region par
• Link the Postgres add-on to the application: clever service link-addon redminePG
• Link the FS Bucket add-on to the application: clever service link-addon redmineFS

production:
  adapter: postgresql
  database: <%= ENV["POSTGRESQL_ADDON_DB"] %>
  host: <%= ENV["POSTGRESQL_ADDON_HOST"] %>
  username: <%= ENV["POSTGRESQL_ADDON_USER"] %>
  port: <%= ENV["POSTGRESQL_ADDON_PORT"] %>
  password: <%= ENV["POSTGRESQL_ADDON_PASSWORD"] %>
  encoding: utf8

• Define a new global secret in config/secrets.yml: touch config/secrets.yml

  production:
    secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
  

• Define all the other configuration variables under config/configuration.yml: touch config/configuration.yml

  production:
    attachments_storage_path: <%= ENV["APP_HOME"] %><%= ENV["ATTACHMENTS_STORAGE_PATH"] %>
  

• Set the Ruby version: clever env set RUBY_VERSION 2.3.1
• Setup the Rails environment to use the production configuration: clever env set RAILS_ENV production
• Use en as language: clever env set REDMINE_LANG en
• Use a newly generated secret: clever env set SECRET_KEY_BASE `./bin/rake secret`
• Setup where to write files: clever env set ATTACHMENTS_STORAGE_PATH /data/attachments
• Define where to mount our FS Bucket:clever env set CC_FS_BUCKET /data:`clever env | awk -F = '/BUCKET_HOST/ { print $2}'`

[ -d tmp ] || mkdir tmp
[ -d tmp/pdf ] || mkdir tmp/pdf
[ -d data/plugin_assets ] || mkdir data/plugin_assets
[ -d tmp/pdf ] || mkdir tmp/pdf
[ -d data/attachments ] || mkdir data/attachments

Deploy

{
  "deploy" : {
    "rakegoals": ["db:migrate"],
    "sidekiq": true
  }
}

git checkout -b clever/deploy
git add Gemfile.lock clevercloud/initDirectories.sh clevercloud/ruby.json config/configuration.yml config/database.yml config/secrets.yml
git commit -m"add clever specifics"
clever deploy

[ldoguin@caolila redmine]$ clever ssh
Opening an ssh shell.
Warning: Permanently added '[195.154.154.198]:40707' (ED25519) to the list of known hosts.
bas@76afae97-762c-43ee-b861-d5db873b553d ~ $ cd app_58f97386-2ec5-48b6-a774-31d64241f692/
bas@76afae97-762c-43ee-b861-d5db873b553d ~/app_58f97386-2ec5-48b6-a774-31d64241f692 $ RAILS_ENV=production bundle exec rake redmine:load_default_data
Select language: ar, az, bg, bs, ca, cs, da, de, el, en, en-GB, es, es-PA, et, eu, fa, fi, fr, gl, he, hr, hu, id, it, ja, ko, lt, lv, mk, mn, nl, no, pl, pt, pt-BR, ro, ru, sk, sl, sq, sr, sr-YU, sv, th, tr, uk, vi, zh, zh-TW [en] 
====================================
Default configuration data loaded.
bas@76afae97-762c-43ee-b861-d5db873b553d ~/app_58f97386-2ec5-48b6-a774-31d64241f692 $ 

Setup and Deploy a Preproduction Redmine

clever addon create postgresql-addon --plan s --region eu redminePG
clever addon create fs-bucket --plan s --region eu staging-redmineFS
clever create --type ruby staging-redmine --region par
clever service --alias staging-redmine link-addon staging-redminePG
clever service --alias staging-redmine link-addon staging-redmineFS
clever env --alias staging-redmine set RUBY_VERSION 2.3.1
clever env --alias staging-redmine set RAILS_ENV production
clever env --alias staging-redmine set REDMINE_LANG en
clever env --alias staging-redmine set SECRET_KEY_BASE `./bin/rake secret`
clever env --alias staging-redmine set ATTACHMENTS_STORAGE_PATH /data/attachments
clever env --alias staging-redmine set CC_FS_BUCKET /data:`clever env --alias staging-redmine  | awk  -F = '/BUCKET_HOST/ { print $2}'`
clever env --alias staging-redmine set CC_PRE_RUN_HOOK ./clevercloud/initDirectories.sh
clever deploy --alias staging-redmine