Forem: Edouard Bonlieu

How to Deploy a Rails Application and Add Authentication using Devise

Edouard Bonlieu — Wed, 09 Feb 2022 17:25:44 +0000

Introduction

Ruby on Rails is a Ruby web application framework that helps make building modern web applications an easy experience. It powers software created by companies like Airbnb, GitHub, Soundcloud, Shopify, and a host of other companies.

User authentication is a common feature present in most software products. It is especially important in software products where the identity of a user is required before they are granted access to the system.

In this tutorial, you will learn how to implement authentication in a Rails application by using Devise, an authentication solution for Rails. We will deploy this application on Koyeb and enjoy the platform's built-in autoscaling, automatic HTTPS, global load balancing, and more. With Koyeb's git-driven deployment, all changes you make to your application will be automatically built and promoted once the build and necessary healthchecks are complete.

Requirements

To successfully follow this tutorial, you need the following:

Ruby programming language installed on your local development machine. This tutorial uses version 2.6.6 of Ruby.
Ruby on Rails framework installed on your local development machine. This demo application in this tutorial is built with Rails 6.1
Node.js 10.17 or higher installed on your local development machine.
Yarn package manager installed on your local development machine.
PostgreSQL installed on your local development machine. This tutorial uses version 13 of PostgreSQL.
An ElephantSQL account to get a PostgreSQL database.
A Koyeb account to deploy the demo application.

Steps

The steps to implementing authentication in a Rails application and deploying it to Production on Koyeb include:

Creating a new Rails application.
Setting up the database.
Creating the application homepage.
Adding messages to the application.
Integrate Authentication to the application with Devise.
Deploying the Rails application to Koyeb.

Creating A New Rails Application

In this section, you will create a new Rails application. This demo application will contain messages that should be visible to only authenticated users.

Rails provides a set of commands that make building web applications an easy experience. One such command is the new command, used to generate a new Rails application. To create a new Rails application, open up a terminal window on your machine and run the following command:

rails new secret_message -d=postgresql -T

The command above creates a new Rails application in a directory named secret_message using the options passed to the new command and installs all necessary dependencies. The options passed to the new command specify the following:

The -d flag specifies the type of database to be set up for the application. The demo application for this tutorial will use a Postgres database.
The T flag ensures that dependencies required for writing tests are not installed.

If run successfully, the command will return a bunch of output that ends with text similar to the one below:

├─ websocket-extensions@0.1.4
└─ ws@6.2.2
✨  Done in 13.84s.
Webpacker successfully installed 🎉 🍰

Once the command is done running, move to the created secret_message directory in your terminal by running:

cd secret_message

The secret_message directory is the root directory of the demo application and is where subsequent commands will be run to build out the demo application. To see your new Rails application in the browser, run the command below in your terminal window:

rails server

The command above fires up a Puma server, which is Rails' default web server, and serves the Rails application on port 3000. To see the application, navigate to http://localhost:3000 in your browser, and you will be greeted with Rails' default welcome page.

To stop the Puma server at any time, press the CTRL+C button in the terminal window where it is running. This will stop the running server, and the application will no longer be accessible in the browser.

With the Rails application successfully created, it will be connected to a database in the next section.

Setting Up The Database

Your new Rails application needs a database to store the messages to be shown to authenticated users. In this section, you will connect the demo application to a PostgreSQL database.

Rails offers the ability to set up a different database per software life cycle environment. The database config file found in config/database.yml contains sections to provide database information for the development, test and production environment. The database config file comes pre-filled with database config values for each environment, and these values can be altered as preferred. The default database config for the demo application is shown below:

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
development:
  <<: *default
  database: secret_message_development
test:
  <<: *default
  database: secret_message_test
production:
  <<: *default
  database: secret_message_production
  username: secret_message
  password: <%= ENV['SECRET_MESSAGE_DATABASE_PASSWORD'] %>

For the sake of this tutorial, we will use the default database config provided by Rails. To set up a database for a Rails application using the database config values, Rails provides a db:prepare command. This command creates databases using values set in the database config. While in the secret_message directory in your terminal, run the following command to create the necessary databases:

rails db:prepare

This command creates a development and test database and returns the following output when run successfully:

Created database 'secret_message_development'
Created database 'secret_message_test'

With that, you have successfully connected your Rails application to a PostgreSQL database. In the next section, you will create a homepage for the application.

Creating the Homepage

The demo application currently displays the Rails' welcome page as its home page, and in this section, you will replace that with a new homepage.

Rails adopts the Model-View-Controller or MVC pattern of software design. A Rails controller sits between a view and a model, receiving requests and responses and passing them to their corresponding view or model. Creating a homepage for the demo application involves creating a controller and view to handle requests to view the homepage.

For the demo application, requests to view the homepage as well as to view existing messages in the application will be handled using the same controller. Rails provides a controller generator command for creating controllers. To create a controller for the homepage and messages, run the command below in the demo application's root directory in your terminal window:

rails generate controller SecretMessages home index show --skip-assets --no-helper

The controller generator command above accepts three actions; home, index and show. Rails generates a controller action and a corresponding view file for each action passed to it. A controller action in Rails is a method in a controller class that matches a route. It contains the code to be executed when its matching route receives a request. Two additional options are passed to the generator command; the --skip-asset option prevents the generation of CSS asset files for views, while the --no-helper option prevents the creation of a controller helper file.

Running the command generates four files in the project directory. They include:

A secret_messages_controller.rb controller with three methods that correspond to the actions passed to the generator command.
A home.html.erb file which will be the view for the homepage.
An index.html.erb file which will be the view for displaying a list of messages in the application.
A show.html.erb file which will be the view for displaying individual messages.

In addition to generating controller and view files, the command updates the routes file located at config/routes.rb. It adds a get route for each action passed to the command. The routes added to the routes file by the controller generator command need to be edited to specify the application's root route.

A root route in Rails is a route that specifies the page to be displayed when users visit the root URL of a Rails application. In your preferred text editor, open the routes file located at config/routes.rb and make the changes below to the three get routes in the file:

- get 'secret_messages/home'
+ root 'secret_messages#home'
- get 'secret_messages/index'
+ get '/secret_messages', to: 'secret_messages#index'
- get 'secret_messages/show'
+ get '/secret_message/:id', to: 'secret_messages#show', as: :secret_message

In the code above, changes are made to the routes generated by the controller generator command. With the root keyword, the root route is mapped to the home action of the SecretMessages controller. With this, Rails routes requests made to the root URL (/) of the application to the home action of the SecretMessages controller, and its corresponding view is displayed. Also, the /secret_messages route is mapped to the index action of the secret messages controller, while an id param is added to the last route, and it is mapped to the show action of the secret message controller. The route is also named secret_message using the as keyword. Make sure to save the file after making the changes.

With the root route now set up, the application's homepage will no longer display Rails' default welcome page. Before viewing the new homepage, we will add Simple.css to the application. Simple.css is a classless CSS framework that offers basic styles to semantic HTML.

In your text editor, open the application.html.erb file located at app/views/layouts/application.html.erb and add the code below to the <head> section of the HTML:

<head>
  ...
  <link rel="stylesheet" href="https://cdn.simplecss.org/simple.min.css">
</head>

The link loads minified Simple.css styles into the application. Next, replace the markup in the homepage view located at app/views/secret_messages/home.html.erb with the following code:

<h1>Secret Messages</h1>
<figure>
  <img alt="Image" src="https://i.imgur.com/XZcDi6Q.jpeg" width="83%" height="auto" />
  <figcaption>Source: https://imgur.com/gallery/A3fia</figcaption>
</figure>
<p>Secret messages for your eyes only</p>

This adds an image and text for a customized homepage. With that change, save the file and start the Rails server in your terminal window by running rails s and view the application in your browser at http://localhost:3000. You will see the image below:

In this section, you successfully set up a homepage for the demo application, and in the next section, you will add messages to the application.

Adding Messages to the Application

After setting up the demo application's homepage, you will create a model to handle messages in the application in this section.

A Rails model is a class that represents an object, in this case, a message, and facilitates the creation and manipulation of said objects between the database and a Rails application. As with most tasks in a Rails application, Rails provides a generate model command to create a model in a Rails application. The command accepts a model name along with its properties and data types. The message object for the demo application will have two properties: a title and a body.

Run the command below in your terminal window to create a Message model:

rails generate model message title:string body:text

Running the command above instructs Rails to create a Message model with a title and body property, both having a string and text type, respectively. The command generates the following files:

A message.rb file that serves as the message model.
A migration file that contains instructions for creating a messages table in the database. The file's name is a concatenation of the timestamp for when the file was created and the model name. E.g. 20220112205345_create_messages.rb.

Next, you'll edit the message model and add some validation rules. Rails provides validation rules that help define the valid state of model objects. These validation rules are checked before records are saved onto the database. Open the message model located at app/models/message.rb and add the following lines of code to the file:

class Message < ApplicationRecord
  validates :title, :body, presence: true
end

The code above validates the presence of a title and body in every message object and prevents saving message objects where these properties are missing. Save the file after making the changes.

Before message objects can be saved to the database, you need to run the migration file that was generated when creating the message model. The migration file located at db/migrate/<timestamp>_create_messages.rb contains code to create a messages table with a title, body and timestamps columns (created_at and updated_at). To run the migration, run the command below in your terminal window:

rails db:migrate

The command above is Rails' database migrate command. Running this command executes the code in the migration file. When ran successfully, it returns an output similar to the following:

== 20220112205345 CreateMessages: migrating ===================================
-- create_table(:messages)
    -> 0.0310s
== 20220112205345 CreateMessages: migrated (0.0312s) ==========================

With the messages table now created, it can be populated with predefined messages. Rails offers the ability to seed the database with predefined records using a seeds file. The Rails' seeds file is located at db/seed.rb and is triggered by the database seed command.
To create some demo messages for the application, open the seeds file located at db/seed.rb in your favorite text editor and add the following code to the file:

p 'Running seeds'
10.times do |i|
  Message.create!(
    title: "Message #{i}",
    body: "Prow scuttle parrel provost Sail ho shrouds spirits boom mizzenmast yardarm. Pinnace holystone mizzenmast quarter crow's nest nipperkin grog yardarm hempen halter furl. Swab barque interloper chantey doubloon starboard grog black jack gangway rutters.
    Deadlights jack lad schooner scallywag dance the hempen jig carouser broadside cable strike colors. Bring a spring upon her cable holystone blow the man down spanker Shiver me timbers to go on account lookout wherry doubloon chase. Belay yo-ho-ho keelhaul squiffy black spot yardarm spyglass sheet transom heave to.
    Trysail Sail ho Corsair red ensign hulk smartly boom jib rum gangway. Case shot Shiver me timbers gangplank crack Jennys tea cup ballast Blimey lee snow crow's nest rutters. Fluke jib scourge of the seven seas boatswain schooner gaff booty Jack Tar transom spirits."
  )
end
p 'Seeds run successfully'

The code above runs a loop ten times and creates a message record using the predefined values. To run the seeds, run the following code in your terminal window:

rails db:seed

The database seed command above runs the code in the seeds file and populates the database with ten records. When ran successfully, it returns the following output:

"Running seeds"
"Seeds run successfully"

To see the number of messages in the database, open the rails console by running rails console in your terminal window. Running that command will return an irb prompt like this:

Loading development environment (Rails 6.1.4.4)
irb(main):001:0>

In the prompt, run Message.count to see the number of message records in the database. The command should return the following:

(8.8ms)  SELECT COUNT(*) FROM "messages"
=> 10

The query result shows there are ten message records in the database. Type exit to quit the irb prompt at any time.

With the messages in place, add the logic for viewing all and one message. Rails applications can create, read, update and delete records in the database using Active Record. Open the app/controllers/secret_messages_controller.rb file in your text editor and update the index and show methods with the following code:

def index
  @messages = Message.all
end
def show
  @message = Message.find(params[:id])
end

In the index action, Active Record's all method is used to fetch all the message records in the database, and the result is assigned to a @messages instance variable. In the show action, Active Record's find method is used to find the message whose id matches the id in the request params and is assigned to the @message instance variable. The instance variables ensure the messages are accessible in the view.

The last step towards viewing the existing messages in the app is to display them in their respective view pages. The index view will display a list of all messages in the database, while the show page will display individual messages. First, open the index view located at app/views/secret_messages/index.html.erb and replace the code in it with the following:

<h1>Secret Messages</h1>
<% @messages.each do |message| %>
  <h4> <%= link_to message.title, secret_message_path(id: message.id) %> </h4>
<% end %>

The code in the index view above accesses the @messages instance variable created in the index action of the SecretMessages controller and loops over it to render each message's title in a link that links to the show page for each message. Lastly, open the show view located at app/views/secret_messages/show.html.erb and replace the code in it with the code below:

<h1><%= @message.title %></h1>
<p><%= @message.body %></p>
<%= link_to 'Back', secret_messages_path %>

The code in the show view above accesses the @message instance variable declared in the show action of the SecretMessages controller and displays the message's title, body and a link to go back to the index view.
With the code to view the messages in place, restart your Rails server and visit http://localhost:3000/secret_messages in your browser. You will see a page with message titles like the one below:

Clicking on any of the message titles will open up a page like this:

In this section, you created a model to store messages, added a few messages to the database and displayed them in the app. In the next section, you will hide these messages behind an authentication wall.

Integrate Authentication to the Application with Devise

Devise is an authentication solution for Rails. It offers a suite of authentication features that can be easily plugged into any Rails application. In this section, you will add authentication to the demo application with Devise.
To set up Devise, start by adding it to the Gemfile. To do this, open the Gemfile located in the application's root folder and add the following line of code to the end of the file:

gem 'devise'

Next, in your terminal window, run bundle install to install the gem. Devise provides an install generator, which configures it for use in a Rails application when you run it. In your terminal window, run the command below to configure Devise:

rails generate devise:install

Running the command above creates the following files:

A devise.rb file located at config/initializers/devise.rb with Devise configuration options.
An English translation file named devise.yml. It is located at config/locales/devise.en.yml. The command also returns an output with some compulsory and optional instructions. One of the compulsory instructions is to set a default URL option for Devise mailer. To do this for the development environment, in your text editor, open the development.rb file located at config/environments/development.rb and add the following code to the file:

Rails.application.configure do
  ...
  config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
end

Devise uses the default URL options set in the code above to generate URLs in emails. Lastly, add the markup below to the application.html.erb file immediately after the opening <body> tag:

<p class="notice"><%= notice %></p>
<p class="alert"><%= alert %></p>

The code above renders error and success messages generated by Devise.

Messages in the demo application should be visible to only authenticated users. Devise offers a model generator command that creates a Rails model that can be used for authentication. Next, you will create a User model using Devise's model generator command. In your terminal window, run the command below to create a user model with Devise:

rails generate devise User

The command above generates two files; a user model located at app/models/user.rb and a migration file for creating the users table. The command also updates the route files with user routes for Devise. The user model located at app/models/user.rb contains five Devise modules. They include:

database_authenticatable for hashing and storing passwords.
registerable for handling the creation, editing and deletion of user accounts.
recoverable for enabling password reset functionality.
rememberable for generating and clearing tokens for remembering users.
validatable for enabling email and password validation.

The authentication functionalities provided by the five Devise modules in the user model are already implemented and are functional as soon as the users table migration is run. To run the migration, run rails db:migrate in your terminal window. You should get the following output if successful:

== 20220120200559 DeviseCreateUsers: migrating ================================
-- create_table(:users)
    -> 0.0119s
-- add_index(:users, :email, {:unique=>true})
    -> 0.0027s
-- add_index(:users, :reset_password_token, {:unique=>true})
    -> 0.0020s
== 20220120200559 DeviseCreateUsers: migrated (0.0168s) =======================

Devise offers authentication helper functions for Rails controllers and views. They include:

authenticate_user!: This helper function denies controller access to unauthenticated users.
user_signed_in?: This returns a boolean that indicates whether or not a user is signed in.
current_user: This helper returns the currently signed-in user's object.
user_session: This helper returns information about the current user session.

Take note that the Devise helper function names depend on whatever your Devise model is named. This means if your Devise model is Admin instead of User, the helper function names will be authenticate_admin!, admin_signed_in?, current_admin and admin_session.

With the users migration now run, you'll restrict access to the index and show actions of the SecretMessages controller using the authenticate_user! helper. Open the SecretMessages controller and add the following line of code to it:

class SecretMessagesController < ApplicationController
  before_action :authenticate_user!, except: %i[home]
  ...
end

In the code above, the authenticate_user! helper is used in a before_action in the SecretMessages controller. It ensures that unauthenticated users only have access to the home action in the controller. To test this out, restart your Rails server and try viewing all the messages in the app by visiting http://localhost:3000/secret_messages in your browser. You will be redirected to a login page like the one below with a message indicating that you need to be authenticated to continue:

The login page is created by Devise and contains links to other authentication pages like sign up and password reset. To view the messages, go ahead and create an account and log in.

Next, you'll add a login/logout link to the app based on whether or not a user is logged in. In your editor, open the application.html.erb file located at app/views/layouts/application.html.erb and add the following code after the opening <body> tag:

<body>
  <% if user_signed_in? %>
    <p>Welcome <%= current_user.email %></p>
    <%= link_to 'Logout', destroy_user_session_path, method: :delete %>
  <% else %>
    <%= link_to 'Login', new_user_session_path %>
    <%= link_to 'Sign up', new_user_registration_path %>
  <% end %>
  ...
</body>

In the code above, a conditional statement is used to display either a logout link or a login and sign up link based on the value of the user_signed_in? helper. If a user is signed in, the current_user helper is used to display a welcome message that includes the user's email address.

Reloading the application in your browser should show the login and signup or logout text based on your authentication state.

Deploying the Rails application to Koyeb

In this section, you will deploy your Rails application to Koyeb. Koyeb is a serverless platform for deploying applications across clouds and edges. It offers application deployment using pre-built Docker containers or native code using git. In this guide, we are going to deploy our app using the git-driven deployment method.

Start by creating a repository for your Rails application on GitHub. Next, run the commands below in your terminal window to push the application code to your GitHub repo:

git add --all
git commit -m "Complete application with authentication."
git remote add origin git@github.com:<YOUR_GITHUB_USERNAME>/<YOUR_REPOSITORY_NAME>.git
git branch -M main
git push -u origin main

Running the commands above moves the application code from your local development to GitHub. Next, head over to ElephantSQL to create a Postgres database using the following steps:

While logged in and on the instances page, click the "Create a new instance" button.
Enter a name and click the "Select region button".
On the next page, click the "review" button and then click the "Create instance button on the next page".
Select your newly created instance and copy your database URL. Store it in a safe place for use later.

On your Koyeb control panel, go to the Secrets tab and create a new secret. Enter DATABASE_URL as the secret name and paste your database URL as the value. Next, go to the Overview tab and click the Create App button to go to the App creation page.

On the App creation page:

Select GitHub as your deployment method.
In the repositories list, select your application code repository.
Specify the branch you want to deploy. In this case, main.
Set the run command to let Koyeb know how to deploy your app: rails db:migrate && rails db:seed && rails server
In the environment variables section, click the add environment variable button.
Select the Secret type, enter DATABASE_URL as the key and select the DATABASE_URL secret created previously as the value.
Give your app a name. e.g. rails-auth and click the Create App button.

Clicking the Create App button builds and deploys your app and redirects you to a deployment page where you can monitor the deployment. Once the deployment is complete and all necessary health checks have been passed, you can click your public URL to view your application.

Your application now benefits from built-in continuous deployment, global load balancing, end-to-end encryption, its own private network with service mesh and discovery, autohealing, and more.

Conclusion

In this tutorial, you created a Rails application for displaying messages. You also implemented authentication in the application using the Devise gem. Devise offers even more authentication features than what was covered in this tutorial. You can check out their wiki to learn more about Devise.

Since we deployed the application on Koyeb using git-driven deployment, each change you push to your repository will
automatically trigger a new build and deployment on the Koyeb Serverless Platform. Your changes will go live as soon as the deployment
passes all necessary health checks. In case of a failure during deployment, Koyeb maintains the latest working deployment in production
to ensure your application is always up and running.

If you would like to look at the code for the demo application, you can find it here. If you have any questions or suggestions to improve this guide, feel free to reach out to us on Slack.

Deploy a Web Scraper using Puppeteer, Node.js and Docker

Edouard Bonlieu — Mon, 24 Jan 2022 10:37:24 +0000

Introduction

Web scraping is the process of extracting meaningful data from websites. Although it can be done manually, nowadays there are several developer-friendly tools that can automate the process for you.

In this tutorial we are going to create a web scraper using Puppeteer, a Node library developed by Google to perform several automated tasks using the Chromium engine.
Web scraping is just one of the several applications that makes Puppeteer shine. In fact, according to the official documentation on Github Puppeteer can be used to:

Generate screenshots and PDFs of web pages.
Crawl a Single-Page Application and generate pre-rendered content.
Automate form submission, UI testing, keyboard input, and interface interactions.
Create an up-to-date, automated testing environment.
Capture a timeline trace of your site to help diagnose performance issues.
Test Chrome Extensions.

In this guide, we will first create scripts to showcase Puppeteer capabilities, then we will create an API to scrape pages via a simple HTTP API call using Express.js and deploy our application on Koyeb.

Requirements

To successfully follow and complete this guide, you need:

Basic knowledge of JavaScript.
A local development environment with Node.js installed
Basic knowledge of Express.js
Docker installed on your machine
A Koyeb account to deploy and run the application
A GitHub account to version and deploy your application code on Koyeb

This tutorial does not require any prior knowledge of Puppeteer as we will go through every step of setting up and running a web scraper.
However, make sure your version of Node.js is at least 10.18.1 as we are using Puppeteer v3+.

For more information take a look at the official readme on the Puppeteer Github repository.

Steps

To deploy a web scraper using Puppeteer, Express.js, and Docker on Koyeb, you need to follow these steps:

Initializing the project
Your first Puppeteer application
Puppeteer in action
Scrap pages via a simple API call using Express
Deploy the app on Koyeb

Initializing the project

Get started by creating a new directory that will hold the application code.
To a location of your choice, create and navigate to a new directory by executing the following commands:

mkdir puppeteer-on-koyeb
cd puppeteer-on-koyeb

Inside the freshly created folder, we will create a Node.js application skeleton containing the Express.js dependencies that we will need to build our scraping API. In your terminal run:

npx express-generator

You will be prompted with a set of questions to populate the initial package.json file including the project name, version, and description.
Once the command has been completed, your package.json content should be similar to the following:

{
  "name": "puppeteer-on-koyeb",
  "version": "1.0.0",
  "description": "Deploy a Web scraper using Puppeteer, ExpressJS and Docker on Koyeb",
  "private": true,
  "scripts": {
    "start": "node ./bin/www"
  },
  "dependencies": {
    "cookie-parser": "~1.4.4",
    "debug": "~2.6.9",
    "express": "~4.16.1",
    "http-errors": "~1.6.3",
    "jade": "~1.11.0",
    "morgan": "~1.9.1",
  },
  "author": "Samuel Zaza",
  "license": "ISC"
}

Creating the skeleton of the application is going to come handy to organize our files, especially later on when creating we will create our API endpoints.

Next, add Pupetteer, the library we will use to perform the scraping as a project dependency by running:

npm install --save puppeteer

Last, install and configure nodemon. While optional in this guide, nodemon will allow us to automatically restart our server when file changes are detected. This is a great tool to improve the development experience when developing locally. To install nodemon in your terminal, run:

npm install nodemon --save-dev

Then, in your package.json add the following section so we will be able to launch the application in development running npm dev using nodemon and in production running npm start.

{
  "name": "puppeteer-on-koyeb",
  "version": "1.0.0",
  "description": "Deploy a Web scraper using Puppeteer, ExpressJS and Docker on Koyeb",
  "private": true,
+  "scripts": {
+    "start": "node ./bin/www",
+    "dev": "nodemon ./bin/www"
+  },
  "dependencies": {
    "cookie-parser": "~1.4.4",
    "debug": "~2.6.9",
    "express": "~4.16.1",
    "http-errors": "~1.6.3",
    "jade": "~1.11.0",
    "morgan": "~1.9.1",
  },
  "author": "Samuel Zaza",
  "license": "ISC"
}

Execute the following command to launch the application and ensure everything is working as expected:

npm start
# or npm run dev

Open your browser at http://localhost:3000 and you should see the Express welcome message.

Your first Puppeteer application

Before diving into more advanced Puppeteer web scraping capabilities, we will create a minimalist application to take a webpage screenshot and save the result in our current directory.
As mentioned previously, Puppeteer provides several features to control Chrome/Chromium and the ability to take screenshots of a webpage comes very handy.

For this example, we will not dig into each parameter of the screenshot method as we mainly want to confirm our installation works properly.

Create a new JavaScript file named screenshot.js in your project directory puppeteer-on-koyeb by running:

touch screenshot.js

To take a screenshot of a webpage, our application will:

Use Puppeteer, and create a new instance of Browser.
Open a webpage
Take a screenshot
Close the page and browser

Add the code below to the screenshot.js file:

const puppeteer = require('puppeteer');

const URL = 'https://koyeb.com';

const screenshot = async () => {
  console.log('Opening the browser...');
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  console.log(`Go to ${URL}`);
  await page.goto(URL);

  console.log('Taking a screenshot...');
  await page.screenshot({
    path: './screenshot.png',
    fullPage: true,
  });

  console.log('Closing the browser...');
  await page.close();
  await browser.close();
  console.log('Job done!');
};

screenshot();

As you can see, we are taking a screenshot of the Koyeb homepage and saving the result as a png file in the root folder of the project.

You can now run the application by running:

$ node screenshot.js
Opening the browser...
Taking a screenshot...
Closing the browser...
Job done!

Once the execution is completed, a screenshot is saved in the root folder of the application.
You created your first automation using Puppeteer!

Puppeteer in action

Simple Scraper

In this section, we will create a more advanced scenario to scrap and retrieve information from a website's page.
For this example, we will use the Stack Overflow questions pages and instruct Puppeteer to extract each question and excerpt present on the webpage HTML.

Before jumping into the code, in your browser, open the devTools to inspect the webpage source code. You should see a similar block for each question in the HTML:

<div class="question-summary" id="question-summary-11227809">
    <!-- we can ignore the stats wrapper -->
    <div class="statscontainer">...</div>
    <div class="summary">
        <h3><a href="/questions/11227809/why-is-processing-a-sorted-array-faster-than-processing-an-unsorted-array" class="question-hyperlink">Why is processing a sorted array faster than processing an unsorted array?</a></h3>
        <div class="excerpt">
            Here is a piece of C++ code that shows some very peculiar behavior. For some strange reason, sorting the data (before the timed region) miraculously makes the loop almost six times faster. #include &...
        </div>
        <!-- unnecessary wrapper -->
        <div class="d-flex ai-start fw-wrap">...</div>
    </div>
</div>

We will use the JavaScript methods querySelectorAll and querySelector to extract both question and excerpt, and return as result an array of objects.

querySelectorAll: Will be used to to collect each question element. document.querySelectorAll('.question-summary')
querySelector Will be used to extract the question title by calling querySelector('.question-hyperlink').innerText and the excerpt using querySelector('.excerpt').innerText

Back to your terminal, and create a new folder lib containing a file called scraper.js:

mkdir lib
touch lib/scraper.js

Inside the file scraper.js add the following code:

const puppeteer = require('puppeteer');

const URL = 'https://stackoverflow.com/questions';

const singlePageScraper = async () => {
  console.log('Opening the browser...');
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  console.log(`Navigating to ${URL}...`);
  await page.goto(URL, { waitUntil: 'load' });

  console.log(`Collecting the questions...`);
  const questions = await page.evaluate(() => {
    return [...document.querySelectorAll('.question-summary')]
      .map((question) => {
        return {
          question: question.querySelector('.question-hyperlink').innerText,
          excerpt: question.querySelector('.excerpt').innerText,
        };
      });
  });

  console.log('Closing the browser...');

  await page.close();
  await browser.close();

  console.log('Job done!');
  console.log(questions);
  return questions;
};

module.exports = {
  singlePageScraper,
};

Although it looks way more complex than the screenshot.js script, it is actually performing the same actions except for the scraping one. Let's list them:

Create an instance of Browser and open a page.
Go to the URL (and wait for the website to load).
Extract the information from the website and collect the questions into an array of objects.
Close the browser and return the tools list as question-excerpt pair.

You might feel confused about the scraping syntax of:

const questions = await page.evaluate(() => {
  return [...document.querySelectorAll('.question-summary')]
    .map((question) => {
      return {
        question: question.querySelector('.question-hyperlink').innerText,
        excerpt: question.querySelector('.excerpt').innerText,
      };
    });
});

We first call page.evaluate to interact with the page DOM and then we start extracting the question and the excerpt.
Moreover, in the code above, we transformed the result from document.querySelectorAll into a JavaScript array to be able to call map on it and return the pair { question, excerpt } for each converter tool.

To run the function, we can import it into a new file singlePageScraper.js, and run it. Create the file in the root directory of your application:

touch singlePageScraper.js

Then, copy the code below that import the singlePageScraper function and call it:

const { singlePageScraper } = require('./lib/scaper');

singlePageScraper();

Run the script by executing the following command in your terminal:

node singlePageScraper.js

The following output appears in your terminal showing the questions and excerpts retrieved from the StackOverflow questions page:

Opening the browser...
Navigating to https://stackoverflow.com/questions...
Collecting the tools...
Closing the browser...
Job done!
[
  {
    question: 'Google Places Autocomplete for WPF Application',
    excerpt: 'I have a windows desktop application developed in WPF( .Net Framework.)I want to implement Autocomplete textbox using google places api autocomplete, I found few reference which used Web browser to do ...'
  },
  {
    question: 'Change the field of a struct in Go',
    excerpt: "I'm trying to change a parameter of n1's left variable, but n1.left is not available, neither is n1.value or n1.right. What's wrong with this declarations? // lib/tree.go package lib type TreeNode ..."
  },
  ...
 ]

Multi page scraper

In the previous example, we learned how to scrap and retrieve information from a single page.
We can now go even further and instruct Puppeteer to explore and extract information from multiple pages.

For this scenario, we will scrap and extract questions and excerpts from a pre-defined number of StackOverflow questions pages.

Our script will:

Receive the number of pages to scrap as a parameter.
Extract questions and excerpts from a page.
Programmatically click on the "next page" element.
Repeats point 2 and point 3 until the number of pages to scrap is reached.

Based on the previous function singlePageScraper we created in lib/scraper.js we will create a new function taking as an argument the number of pages to scrape.

Let's take a look at the HTML source code of the page to select the correct button element we will emulate the click to go to the next page:

<div class="s-pagination site1 themed pager float-left">
<div class="s-pagination--item is-selected">1</div>
<a class="s-pagination--item js-pagination-item" href="/questions?tab=votes&amp;page=2" rel="" title="Go to page 2">2</a>
...
<a class="s-pagination--item js-pagination-item" href="/questions?tab=votes&amp;page=1470621" rel="" title="Go to page 1470621">1470621</a>
<!-- This is the button we need to select and click on -->
<a class="s-pagination--item js-pagination-item" href="/questions?tab=votes&amp;page=2" rel="next" title="Go to page 2"> Next</a></div>

The Puppeteer class Page provides a handy method click that accepts CSS selectors to simulate a click on an element. In our case, to go to the next page, we decide to use the .pager > a:last-child selector.

In the lib/scraper.js file, create a new function called multiPageScraper:

const puppeteer = require('puppeteer');

const URL = 'https://stackoverflow.com/questions';

const singlePageScraper = async () => {
  console.log('Opening the browser...');
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  console.log(`Navigating to ${URL}...`);
  await page.goto(URL, { waitUntil: 'load' });

  console.log(`Collecting the questions...`);
  const questions = await page.evaluate(() => {
    return [...document.querySelectorAll('.question-summary')]
      .map((question) => {
        return {
          question: question.querySelector('.question-hyperlink').innerText,
          excerpt: question.querySelector('.excerpt').innerText,
        };
      });
  });

  console.log('Closing the browser...');

  await page.close();
  await browser.close();

  console.log('Job done!');
  console.log(questions);
  return questions;
};

+const multiPageScraper = async (pages = 1) => {
+  console.log('Opening the browser...');
+  const browser = await puppeteer.launch();
+  const page = await browser.newPage();
+
+  console.log(`Navigating to ${URL}...`);
+  await page.goto(URL, { waitUntil: 'load' });
+
+  const totalPages = pages;
+  let questions = [];
+
+  for (let initialPage = 1; initialPage <= totalPages; initialPage++) {
+    console.log(`Collecting the questions of page ${initialPage}...`);
+    let pageQuestions = await page.evaluate(() => {
+      return [...document.querySelectorAll('.question-summary')]
+        .map((question) => {
+          return {
+            question: question.querySelector('.question-hyperlink').innerText,
+            excerpt: question.querySelector('.excerpt').innerText,
+          }
+        });
+    });
+
+    questions = questions.concat(pageQuestions);
+    console.log(questions);
+  // Go to next page until the total number of pages to scrap is reached
+    if (initialPage < totalPages) {
+      await Promise.all([
+        await page.click('.pager > a:last-child'),
+        await page.waitForSelector('.question-summary'),
+      ])
+    }
+  }
+
+  console.log('Closing the browser...');
+
+  await page.close();
+  await browser.close();
+
+  console.log('Job done!');
+  return questions;
+};

module.exports = {
  singlePageScraper,
+  multiPageScraper,
};

Since we are collecting questions and related excerpts for multiple pages, we use a for loop to retrieve the list of questions for each page.
Each questions retrieved for a page is then concatenated in an array questions which is returned once the fetching is completed.

As we did for the single page scraper example, create a new file multiPageScraper.js in the root directory to import and call the multiPageScraper function:

touch multiPageScraper.js

Then, add the following code:

const { multiPageScraper } = require('./lib/scaper');

multiPageScraper(2);

For the purpose of the script, we are hardcoding the number of pages to fetch to 2. We will make this dynamic when we will build the API.

In your terminal execute the following command to run the script:

node multiPageScraper.js

The following output appears in your terminal showing the questions and excerpts retrieved for each page scraped:

Opening the browser...
Navigating to https://stackoverflow.com/questions...
Collecting the questions of page 1...
[
  {
    question: 'Blazor MAIUI know platform',
    excerpt: 'there is some way to known the platform where is running my Blazor maui app?. Select not work property in "Windows" (you need use size=2 or the list not show), i would read the platform in ...'
  },
  ...
]
Collecting the questions of page 2...
[
  {
    question: 'Blazor MAIUI know platform',
    excerpt: 'there is some way to known the platform where is running my Blazor maui app?. Select not work property in "Windows" (you need use size=2 or the list not show), i would read the platform in ...'
  },
  ...
]
Closing the browser...
Job done!

In the next section, we will write a simple API server containing one endpoint to scrap a user-defined number of pages and return the list of questions and excerpts scraped.

Scrap pages via a simple API call using Express

We are going to create a simple Express.js API server having an endpoint /questions that accepts a query parameter pages and returns the list of questions and excerpts from page 1 to the page sent as parameter.

For instance, to retrieve the first three pages of questions and their excerpts from Stack Overflow, we will call:

http://localhost:3000/questions?pages=3

To create the questions endpoit, go to the routes directory and create new file question.js:

cd routes
touch questions.js

Then, add the code below to the question.js file:

const express = require('express');
const scraper = require('../lib/scaper');

const router = express.Router();

router.get('/', async (req, res, next) => {
  // 1. Get the parameter "pages"
  const { pages } = req.query;
  // 2. Call the scraper function
  const questions = await scraper.multiPageScraper(pages);
  // 3. Return the array of questions to the client
  res.status(200).json({
    statusCode: 200,
    message: 'Questions correctly retrieved',
    data: { questions },
  });
});

module.exports = router;

What the code does is:

Get the query parameter pages.
Call the newly created function multiPageScraper and pass the pages value.
Return the array of questions back to the client.

We now need to define the questions route in the Express router. To do so, open app.js and add the following

const createError = require('http-errors');
const express = require('express');
const path = require('path');
const cookieParser = require('cookie-parser');
const logger = require('morgan');

const indexRouter = require('./routes/index');
+const questionsRouter = require('./routes/questions');

const app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', indexRouter);
+app.use('/questions', questionsRouter);

Note that thanks to the Express generator we used to initialize our project, we do not have to setup our server from scratch, a few middlewrides are already setup for us.
Run the server again and try the to call the /questions API endpoint using either the browser or cURL.

Here is the ouput you should get running it from your terminal using cURL:

$ curl http://localhost:3000/questions\?pages\=2 | jq '.'
{
  "statusCode": 200,
  "message": "Questions correctly retrieved",
  "data": {
    "questions": [
      {
        "question": "Is there a way to return float or integer from a conditional True/False",
        "excerpt": "n_level = range(1, steps + 2) steps is user input,using multi-index dataframe for i in n_level: if df['Crest'] >= df[f'L{i}K']: df['Marker'] = i elif df['Trough'] &..."
      },
      {
        "question": "Signin With Popup - Firebase and Custom Provider",
        "excerpt": "I am working on an application that authenticates users with a Spotify account. I have a working login page, however, I would prefer users to not be sent back to the home page when they sign in. I ..."
      },
...

And we are done! We now have a web scraper that with minimal changes can scrap any websites.

Deploy the app on Koyeb

Now that we have a working server, we can demonstrate how to deploy the application on Koyeb.
Koyeb simple user interface gives you two choices to deploy our app:

Deploy native code using git-driven deployment
Deploy pre-built Docker containers from any public or private registries.

Since we are using Puppeteer, we need some extra system packages installed so we will deploy on Koyeb using Docker.

In this guide, I won't go through the steps of creating a Dockerfile and pushing it to the Docker registry but if you are interested in learning more, I suggest you start with the official documentation.

Before we start working with Docker, we have to perform a change into the /lib/scaper.js file:

const puppeteer = require('puppeteer');

const URL = 'https://stackoverflow.com/questions';

const singlePageScraper = async () => {
  console.log('Opening the browser...');
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  console.log(`Navigating to ${URL}...`);
  await page.goto(URL, { waitUntil: 'load' });

  console.log(`Collecting the questions...`);
  const questions = await page.evaluate(() => {
    return [...document.querySelectorAll('.question-summary')]
      .map((question) => {
        return {
          question: question.querySelector('.question-hyperlink').innerText,
          excerpt: question.querySelector('.excerpt').innerText,
        };
      });
  });

  console.log('Closing the browser...');

  await page.close();
  await browser.close();

  console.log('Job done!');
  console.log(questions);
  return questions;
};

const multiPageScraper = async (pages = 1) => {
  console.log('Opening the browser...');
-  const browser = await puppeteer.launch();
+  const browser = await puppeteer.launch({
+      headless: true,
+      executablePath: '/usr/bin/chromium-browser',
+      args: [
+        '--no-sandbox',
+        '--disable-gpu',
+      ]
+  });
  const page = await browser.newPage();

  console.log(`Navigating to ${URL}...`);
  await page.goto(URL, { waitUntil: 'load' });

  const totalPages = pages;
  let questions = [];

  for (let initialPage = 1; initialPage <= totalPages; initialPage++) {
    console.log(`Collecting the questions of page ${initialPage}...`);
    let pageQuestions = await page.evaluate(() => {
      return [...document.querySelectorAll('.question-summary')]
        .map((question) => {
          return {
            question: question.querySelector('.question-hyperlink').innerText,
            excerpt: question.querySelector('.excerpt').innerText,
          }
        });
    });

    questions = questions.concat(pageQuestions);
    console.log(questions);
  // Go to next page until the total number of pages to scrap is reached
    if (initialPage < totalPages) {
      await Promise.all([
        await page.click('.pager > a:last-child'),
        await page.waitForSelector('.question-summary'),
      ])
    }
  }

  console.log('Closing the browser...');

  await page.close();
  await browser.close();

  console.log('Job done!');
  return questions;
};

module.exports = {
  singlePageScraper,
  multiPageScraper,
};

These extra parameters are required to properly run Puppeteer inside a Docker container.

Dockerize the application and push it to the Docker Hub

Get started by creating a Dockerfile containing the following:

FROM node:lts-alpine

WORKDIR /app

RUN apk update && apk add --no-cache nmap && \
    echo @edge http://nl.alpinelinux.org/alpine/edge/community >> /etc/apk/repositories && \
    echo @edge http://nl.alpinelinux.org/alpine/edge/main >> /etc/apk/repositories && \
    apk update && \
    apk add --no-cache \
      chromium \
      harfbuzz \
      "freetype>2.8" \
      ttf-freefont \
      nss

ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true

COPY . /app

RUN npm install

EXPOSE 3000

CMD ["npm", "start"]

This is a fairly simple Dockerfile. We inherit from the Node alpine base image, install the dependencies required by Puppeteer, add our web scraper application code and indicate how to run it.

We can now build the Docker image by running the following command:

docker build . -t <YOUR_DOCKER_USERNAME>/puppeteer-on-koyeb

Take care to replace <YOUR_DOCKER_USERNAME> with your Docker Hub username.

Once the build succeeded, we can push our image to the Docker Hub running:

docker push <YOUR_DOCKER_USERNAME>/puppeteer-on-koyeb

Deploy the app on Koyeb

Let's login to the Koyeb Control Panel and click on the Create App button.
You land on the App creation page.

In "Deployment method", select Docker
Enter the Docker image you just pushed <YOUR_DOCKER_USERNAME>/puppeteer-on-koyeb to the Docker Hub. We do not need to configure the extra args or command fields
Pick the container size, server region, and number of instances you'd like to run your application
In the Ports section, change the port value from 8080 to 3000, this is used by Koyeb to determine if your service is healthy. The 3000 port is the port our application listen to
Give your Koyeb App a name.

Once you click the Create App button, you will automatically be redirected to the Koyeb App page where you can follow the progress of your application deployment. Once your app is deployed, click on the Public URL ending with koyeb.app.

Then ensure everything is working as expected by retrieving the two first pages of questions from Stack Overflow running:

curl http://<KOYEB_APP_NAME>-<KOYEB_ORG_NAME>.koyeb.app/questions?pages=2

If everything is working fine, you should see the list of questions returned by the API.

Conclusion

First of all, congratulations on reaching this point! It was a long journey but we now have all the basic knowledge to successfully create and deploy a web scraper.

Starting from the beginning, we played with Puppeteer screenshot capabilities and slowly built up a fairly robust scraper that can automatically change the page to retrieve questions from StackOverflow.

Successively, we moved from a simple script to a running Express API server which exposes a specific endpoint to call the script and scrap a dynamic number of pages based on the query parameter sent along with the API call.

Finally, the cherry on the top is the deployment of our server with Koyeb:
Thanks to the simplicity of its deployment using pre-build Docker images we can now perform our scraping in a production environment.

If you have any questions or suggestions regarding this guide, feel free to reach out on Slack.

Deploy a Rest API using Koa, Prisma, and Aiven on Koyeb

Edouard Bonlieu — Mon, 17 Jan 2022 14:50:30 +0000

Introduction

In this tutorial, we will showcase how to build a Notes REST API using Koajs, Prisma, and Aiven on Koyeb. By running your application on Koyeb, you natively benefit from continuous deployment using git, autoscaling, autohealing, TLS encryption, a Global Edge Network CDN, and more.

Koa is a minimalist, expressive and robust web framework for web applications and APIs. We will use Koa to build our application REST API.

Aiven is a fully-managed, multi-cloud data platform allowing you to deploy a wide range way of open-source data services and databases such as MySQL, PostgreSQL, InfluxDB, Redis, and more. We will use Aiven to provision a MySQL database and use it to store our Notes information.

Last, we will make use of Prisma, an ORM offering powerful primitive that will help us interact with the MySQL database from our application intuitively and safely.

At the end of this guide, you will have a working Notes application deployed on Koyeb using git-driven deployment.

Requirements

To successfully follow and complete this guide, you need:

A local development environment with Node.js installed
A Koyeb account to deploy and run the application
An Aiven account to run the MySQL database
A GitHub account to version and deploy your application code on Koyeb

Steps

To deploy the Rest API using Koa, Prisma, and Aiven on Koyeb, you need to follow these three steps:

Deploy a MySQL database on Aiven
Create the Notes REST API using Koa and Prisma
Deploy the Notes application to Koyeb

Deploy a MySQL database on Aiven

Aiven is a fully-managed, multi-cloud data platform allowing you to deploy a wide range of open-source databases including MySQL, PostgreSQL, InfluxDB, Redis, and many more.
In this guide, we will deploy a MySQL database on Aiven and use it as the data backend for our application.

Aiven provides a 1-month free trial with $300 credits to try out the platform.

On the Aiven control panel, click the Create a new service button on the top right corner.
You land on the Create Service page where you need to select the service type to deploy. Select the MySQL service.

Then, select Google Cloud as the cloud service provider to run the MySQL database.

Select the Hobbyist plan which is perfect for small test environments and is ideal to follow this guide.

Last, click the Create Service button to provision the MySQL database. You land on the Aiven Services page where you can see the newly created service.

Click the MySQL service to go to the service details page and retrieve the MySQL database credentials.

Take note of the Service URI in a secure place, that’s what we will use to connect to our database in our application. Embedded in the URI are the MySQL user, password, host, and port as well as a default database name, so don't share it publicly!

Tip: If you’re more of a command line person, you can make use of the Aiven CLI as well.

Connect to the database

Before we go further, let's ensure we can properly connect to the MySQL database we just deployed to ensure everything is working as expected.
In the terminal, run the following command to connect to the database:

mysql --user AIVEN_DB_USER --password=AIVEN_DB_PASSWORD --host AIVEN_DB_HOST --port AIVEN_DB_PORT defaultdb

Don't forget to replace AIVEN_DB_USER, AIVEN_DB_PASSWORD, AIVEN_DB_HOST, and AIVEN_DB_PORT with your own information.

Once the command is executed, if everything goes well, you should see the following output:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 139834
Server version: 8.0.26 Source distribution

Copyright (c) 2000, 2021, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

Create the Notes REST API using Koa and Prisma

Create the Koa application

First, we will create a new Koa application and install the necessary packages required by our application.
To start, create a new directory for our application code and change to the newly created directory using the command below:

mkdir koa-prisma-notes-api
cd koa-prisma-notes-api

Next, initialize a new Node project using the command below:

npm init -y

This command creates a package.json file inside the koa-prisma-notes-api directory containing basic information such as the project name, version, and author.

We can then install the dependencies required by our API using the npm command:

npm install koa @koa/router koa-body

This command installs Koa, koa-router a router for Koa which we will use to define the API endpoints, and koa-body a body-parser middleware to parse the request body as JSON.

With those dependencies installed, create a new src containing an index.js file:

mkdir src && cd src
touch index.js

Open and add the following code to the index.js file using your preferred editor:

// src/index.js

const Koa = require('koa')
const Router = require('@koa/router')
const KoaBody = require('koa-body')

const app = new Koa()
const router = new Router()


app.use(KoaBody())
app
  .use(router.routes())
  .use(router.allowedMethods())

app.listen(8080, () => {
  console.log('Server running at: http://localhost:8080')
})

In the code above, we:

import the dependencies required by our application,
create a new instance of Koa to which everything will be tied to,
add the Koa router and Koa body middlewares to the Koa application,
launch the Koa server on port 8080.

You can then start the server by running in your terminal:

node src/index.js

This works fine but for a better development experience, we would like the server to restart automatically whenever we make changes.
For that, we will make use of Nodemon which will automatically restart the application when file changes are detected in the directory.

To install nodemon in your terminal, run the following command:

npm install nodemon --save-dev

Then we can start the server by running:

nodemon src/index.js

Next, add the following scripts to your package.json to ease the launch of the application for development and production as below:

// package.json

"scripts": {
  "dev": "nodemon src/index.js",
  "start": "node src/index.js"
},

Install Prisma

Prisma is a next-generation ORM for Node.js and TypeScript. It supports multiple databases such as PostgreSQL, MySQL, SQL Server, SQLite, and MongoDB.
We will use Prisma to manage our schemas and query the database from our application.

Start by adding Prisma to your project using the following command:

npm install prisma --save-dev

Then initialize a fresh Prisma project by running:

npx prisma init --datasource-provider mysql

This will create a new prisma directory that contains a schema.prisma file and a .env and file in the project root.
The schema.prisma file contains things like the Prisma client generator, the database connection, and the Prisma schema which will be used to define the database schema.

✔ Your Prisma schema was created at prisma/schema.prisma
  You can now open it in your favorite editor.

Next steps:
1. Set the DATABASE_URL in the .env file to point to your existing database. If your database has no tables yet, read https://pris.ly/d/getting-started
2. Set the provider of the datasource block in schema.prisma to match your database: postgresql, mysql, sqlite, sqlserver or mongodb (Preview).
3. Run prisma db pull to turn your database schema into a Prisma schema.
4. Run prisma generate to generate the Prisma Client. You can then start querying your database.

More information in our documentation:
https://pris.ly/d/getting-started

The .env file contains the environment variables that will be put into the system environments. Prisma will then read and use these variables.
Edit the .env file by replacing the DATABASE_URL value with your Aiven database connection string.

// .env

+DATABASE_URL="mysql://AIVEN_DB_USER:AIVEN_DB_PASSWORD@AIVEN_DB_HOST:AIVEN_PORT/AIVEN_DB_DATABASE_NAME?ssl-mode=REQUIRED"
-DATABASE_URL="mysql://johndoe:randompassword@localhost:3306/mydb"

The Prisma schema file contains the configuration of the Prisma setup:

// prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

Create a Prisma schema for the notes API

Our application will just have one model called Note. To create the data model definition in the prisma/schema.prisma file add the following:

// prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

+model Note {
+  id        Int      @id @default(autoincrement())
+  title     String   @db.VarChar(255)
+  content   String?  @db.Text
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

Each field definition is composed of the following parts:

The field name
The field type
Type modifiers (optional)
Attributes, including native database type attributes (optional)

Our Note model has a couple of fields:

id: of type Int marked as the primary key using the @id modifier and set to a default value which will be auto-incremented
title: of type String and using the native database type varchar with a length of 255.
content: of type String but marked as optional by using ? and of native database type text
createdAt: of type DateTime with a default value set to the current time when a note is created
updatedAt: of type DateTime with a default value set to the time when the note is updated

Create your first Prisma migration

With the note model defined, we can now perform a Prisma migration to synchronize our database schema with our Prisma schema. To do so, run the following command in your terminal:

$ npx prisma migrate dev

Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": MySQL database "defaultdb" at "mysql-xyz.aivencloud.com:28784"

✔ Enter a name for the new migration: …
Applying migration `20211229094929_`

The following migration(s) have been created and applied from new schema changes:

migrations/
  └─ 20211229094929_/
    └─ migration.sql

Your database is now in sync with your schema.

✔ Generated Prisma Client (3.7.0 | library) to ./node_modules/@prisma/client in 822ms

Once the migration is completed, your prisma directory structure should now look as below:

prisma
├── migrations
│   ├── 20211229094929_
│   │   └── migration.sql
│   └── migration_lock.toml
└── schema.prisma

While it’s totally fine to use migrate dev to run migrations in a development environment, in production, or in your CI/CD pipeline, we need to make sure we apply any pending migrations and create the database if it does not exist using prisma migrate deploy before running the application.

To make doing that straightforward, let’s add a build script in the package.json file:

// package.json

"scripts": {
    "build": "prisma generate && prisma migrate deploy",
},

Create seeds data

We are now ready to seed our database with some mock data using Prisma. Into the prisma directory, create a new seed.js file containing the following code:

// prisma/seed.js

const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()

async function main() {
  await prisma.note.createMany({
    data: [
      {
        title: 'Deploy a Go Gin Application on Koyeb',
        content:
          'This tutorial explains how to deploy a Go Gin application on the Koyeb serverless platform using git-driven deployment.',
      },
      {
        title:
          'Deploy a Laravel Application with Continuous Deployment on Koyeb',
        content:
          'This guide shows how to deploy a Laravel application on the Koyeb Serverless Platform using git-driven deployment. Git-driven deployment allows you to push your code without having to take care of the build, deployment, and run process. Koyeb handles all this for you.',
      },
      {
        title: 'Continuous Deployment of a NestJS Application on Koyeb',
        content:
          'This guide explains how to continuously deploy a NestJS application on the Koyeb serverless platform.',
      },
    ],
  })
}

main()
  .catch((e) => {
    console.error(e)
    process.exit(1)
  })
  .finally(async () => {
    await prisma.$disconnect()
  })

The script uses the Prisma client to insert data into the database. You may notice that we are using the createMany() function to insert multiple data at once.

Next, add a prisma section in our package.json file to be able to run the script using the Prisma CLI:

// package.json

"prisma": {
  "seed": "node prisma/seed.js"
}

Then to seed the database, execute:

$ npx prisma db seed
Environment variables loaded from .env
Running seed command `node prisma/seed.js` ...

🌱  The seed command has been executed.

Building the Notes Koa API

With all the setup out of the way, let’s start building the API’s functionality. As mentioned earlier, the note API is going to contain basic CRUD operations.
As seen briefly in the seed section above, we will be making use of the Prisma client to interact with our database and perform the necessary CRUD operation.

Add the code below inside the index.js file containing our Koa application:

// src/index.js
+const { PrismaClient } = require('@prisma/client')
const Koa = require('koa')
const Router = require('@koa/router')
const KoaBody = require('koa-body')

const app = new Koa()
const router = new Router()

+router.get('/notes', async (ctx) => {
+  const notes = await prisma.note.findMany()
+
+  ctx.response.status = 200
+  ctx.body = {
+    message: 'Notes retrieved',
+    data: notes,
+  }
+})

+router.get('/notes/:id', async (ctx) => {
+  const note = await prisma.note.findUnique({
+    where: { id: Number(ctx.params.id) },
+  })
+
+  if (note) {
+    ctx.response.status = 200
+    ctx.body = {
+      message: 'Note retrieved',
+      data: note,
+    }
+  } else {
+    ctx.response.status = 404
+    ctx.body = {
+      message: 'Note not found',
+    }
+  }
+})

+router.post('/notes', async (ctx) => {
+  const note = await prisma.note.create({
+    data: {
+      title: ctx.request.body.title,
+      content: ctx.request.body.content,
+    },
+  })
+
+  ctx.response.status = 201
+  ctx.body = {
+    message: 'Note created',
+    data: note,
+  }
+})

+router.put('/notes/:id', async (ctx) => {
+  const note = await prisma.note.update({
+    where: { id: Number(ctx.params.id) },
+    data: {
+      title: ctx.request.body.title,
+      content: ctx.request.body.content,
+    },
+  })

+  ctx.response.status = 200
+  ctx.body = {
+    message: 'Note updated',
+    data: note,
+  }
+})

+router.delete('/notes/:id', async (ctx) => {
+  await prisma.note.delete({ where: { id: Number(ctx.params.id) } })
+
+  ctx.response.status = 204
+  ctx.body = {
+    message: 'Note delete',
+  }
+})

app.use(KoaBody())
app
  .use(router.routes())
  .use(router.allowedMethods())

app.listen(8080, () => {
  console.log('Server running at: http://localhost:8080')
})

The code above adds the following routes to our Note application:

GET /notes: retrieves all notes and uses the Prisma client findMany() function to retrieve the notes.
GET /notes/:id: retrieves a single note from its ID and uses the Prisma findUnique() function to retrieve the note. If the note is found the API responds with an HTTP code 200 and 404 otherwise.
POST /notes: creates a new note. It uses the Prisma create() function to create the note and returns a 201 HTTP code when the note is created.
PUT /notes/:id: updates an existing note from its ID. It uses the Prisma update() function to update the note and returns a 200 HTTP code when the note is updated.
DELETE /notes/:id: deletes a note from its ID. This endpoint uses the Prisma delete() function to delete the note and returns a 204 HTTP code when the note is deleted.

Run the Notes API application

It's time to test out the API to ensure everything is working as expected.

First, launch the server by running:

npm run dev

The server will start and be accessible at http://localhost:8080.

Then, let's play with the API using curl to test the different endpoints:

# Retrieve all notes
$ curl -s http://localhost:8080/notes | jq .

# Output
{
  "message": "Notes retrieved",
  "data": [
    {
      "id": 1,
      "title": "Deploy a Go Gin Application on Koyeb",
      "content": "This tutorial explains how to deploy a Go Gin application on the Koyeb serverless platform using git-driven deployment.",
      "status": "draft",
      "createdAt": "2021-12-29T10:10:57.293Z",
      "updatedAt": "2021-12-29T10:10:57.294Z"
    },
    {
      "id": 2,
      "title": "Deploy a Laravel Application with Continuous Deployment on Koyeb",
      "content": "This guide shows how to deploy a Laravel application on the Koyeb Serverless Platform using git-driven deployment. Git-driven deployment allows you to push your code without having to take care of the build, deployment, and run process. Koyeb handles all this for you.",
      "status": "draft",
      "createdAt": "2021-12-29T10:10:57.294Z",
      "updatedAt": "2021-12-29T10:10:57.294Z"
    },
    {
      "id": 3,
      "title": "Continuous Deployment of a NestJS Application on Koyeb",
      "content": "This guide explains how to continuously deploy a NestJS application on the Koyeb serverless platform.",
      "status": "draft",
      "createdAt": "2021-12-29T10:10:57.294Z",
      "updatedAt": "2021-12-29T10:10:57.294Z"
    }
  ]
}

# Retrieve a single note
$ curl -s http://localhost:8080/notes/1 | jq .

# Output
{
  "message": "Note retrieved",
  "data": {
    "id": 1,
    "title": "Deploy a Go Gin Application on Koyeb",
    "content": "This tutorial explains how to deploy a Go Gin application on the Koyeb serverless platform using git-driven deployment.",
    "status": "draft",
    "createdAt": "2021-12-29T10:10:57.293Z",
    "updatedAt": "2021-12-29T10:10:57.294Z"
  }
}

# Create a new note
$ curl -d '{"title": "Sample note title", "content": "Sample note content"}' -H 'Content-Type: application/json' -X POST http://localhost:8080/notes | jq .

# Output

{
  "message": "Note created",
  "data": {
    "id": 5,
    "title": "Sample note title",
    "content": "Sample note content",
    "status": "draft",
    "createdAt": "2021-12-29T10:47:16.903Z",
    "updatedAt": "2021-12-29T10:47:16.904Z"
  }
}

# Update a note
$ curl -d '{"title": "Sample note title [UPDATED]", "content": "Sample note content"}' -H 'Content-Type: application/json' -X PUT http://localhost:8080/notes/5 | jq .

# Output
{
  "message": "Note updated",
  "data": {
    "id": 5,
    "title": "Sample note title [UPDATED]",
    "content": "Sample note content",
    "status": "draft",
    "createdAt": "2021-12-29T10:47:16.903Z",
    "updatedAt": "2021-12-29T10:50:44.279Z"
  }
}

# Delete a note
curl -X DELETE http://localhost:8080/notes/5

Update the Prisma schema (optional)

Our application is now feature complete. But before we wrap up, let’s make a small refactor by adding status to notes. That way, we can have notes that are in draft and those published.

Let’s start by updating the Prisma schema. Since we want to have predetermined status (draft and published), we are going to create an enum and add a new field called status set to the type of the Status enum with a default value of draft to the Note model.

// prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

+enum Status {
+  draft
+  published
+}

model Note {
  id        Int      @id @default(autoincrement())
  title     String   @db.VarChar(255)
  content   String?  @db.Text
+ status    Status   @default(draft)
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

Next, we need to create a new migration to synchronize our database schema with the Prisma schema by running:

$ npx prisma migrate dev
Environment variables loaded from .env
Prisma schema loaded from prisma/schema.prisma
Datasource "db": MySQL database "defaultdb" at "mysql-xyz.aivencloud.com:28784"

✔ Enter a name for the new migration: … add status
Applying migration `20211229125948_add_status`

The following migration(s) have been created and applied from new schema changes:

migrations/
  └─ 20211229125948_add_status/
    └─ migration.sql

Your database is now in sync with your schema.

✔ Generated Prisma Client (3.7.0 | library) to ./node_modules/@prisma/client in 2.05s

When prompted for a name for the new migration, we’ll enter “add status”.

Once the migration is completed, the migrations directory should look like below:

prisma/migrations
├── 20211229125830_
│   └── migration.sql
├── 20211229125948_add_status
│   └── migration.sql
└── migration_lock.toml

Last, update the application to use the freshly created status field by editing the Koa application index.js file:

// src/index.js
const { PrismaClient } = require('@prisma/client')
const Koa = require('koa')
const Router = require('@koa/router')
const KoaBody = require('koa-body')

const app = new Koa()
const router = new Router()

router.get('/notes', async (ctx) => {
-  const notes = await prisma.note.findMany()
+  const notes = await prisma.note.findMany({
+    where: { status: ctx.query.status },
+  })

  ctx.response.status = 200
  ctx.body = {
    message: 'Notes retrieved',
    data: notes,
  }
})

router.get('/notes/:id', async (ctx) => {
  const note = await prisma.note.findUnique({
    where: { id: Number(ctx.params.id) },
  })

  if (note) {
    ctx.response.status = 200
    ctx.body = {
      message: 'Note retrieved',
      data: note,
    }
  } else {
    ctx.response.status = 404
    ctx.body = {
      message: 'Note not found',
    }
  }
})

router.post('/notes', async (ctx) => {
  const note = await prisma.note.create({
    data: {
      title: ctx.request.body.title,
      content: ctx.request.body.content,
+     status: ctx.request.body.status,
    },
  })

  ctx.response.status = 201
  ctx.body = {
    message: 'Note created',
    data: note,
  }
})

router.put('/notes/:id', async (ctx) => {
  const note = await prisma.note.update({
    where: { id: Number(ctx.params.id) },
    data: {
      title: ctx.request.body.title,
      content: ctx.request.body.content,
+     status: ctx.request.body.status,
    },
  })

  ctx.response.status = 200
  ctx.body = {
    message: 'Note updated',
    data: note,
  }
})

router.delete('/notes/:id', async (ctx) => {
  await prisma.note.delete({ where: { id: Number(ctx.params.id) } })

  ctx.response.status = 204
  ctx.body = {
    message: 'Note delete',
  }
})

app.use(KoaBody())
app
  .use(router.routes())
  .use(router.allowedMethods())

app.listen(8080, () => {
  console.log('Server running at: http://localhost:8080')
})

We can now filter the notes based on their status when we call the /notes endpoint and can also update the status of a note.
For instance to list all notes with the draft status run:

# Retrieve all draft notes
$ curl -s http://localhost:8080/notes?status=draft | jq .

# Output
{
  "message": "Notes retrieved",
  "data": [
    {
      "id": 1,
      "title": "Deploy a Go Gin Application on Koyeb",
      "content": "This tutorial explains how to deploy a Go Gin application on the Koyeb serverless platform using git-driven deployment.",
      "status": "draft",
      "createdAt": "2021-12-29T12:58:37.639Z",
      "updatedAt": "2021-12-29T12:58:37.640Z"
    },
    {
      "id": 2,
      "title": "Deploy a Laravel Application with Continuous Deployment on Koyeb",
      "content": "This guide shows how to deploy a Laravel application on the Koyeb Serverless Platform using git-driven deployment. Git-driven deployment allows you to push your code without having to take care of the build, deployment, and run process. Koyeb handles all this for you.",
      "status": "draft",
      "createdAt": "2021-12-29T12:58:37.639Z",
      "updatedAt": "2021-12-29T12:58:37.640Z"
    },
    {
      "id": 3,
      "title": "Continuous Deployment of a NestJS Application on Koyeb",
      "content": "This guide explains how to continuously deploy a NestJS application on the Koyeb serverless platform.",
      "status": "draft",
      "createdAt": "2021-12-29T12:58:37.639Z",
      "updatedAt": "2021-12-29T12:58:37.640Z"
    }
  ]
}

Deploy the Notes application on Koyeb

We are now ready to deploy our note API on Koyeb.

Koyeb is a developer-friendly serverless platform to deploy apps globally. It supports deploying applications using pre-built Docker containers or native code using git.
For the purpose of this tutorial, we will deploy our application using git-driven deployment.

Head over to GitHub to create a new repository and push the application code running:

git init
git add --all
git commit -m "Initial commit"
git branch -M main
git remote add origin https://github.com/YOUR_GITHUB_USERNAME/koa-prisma-notes-api.git
git push -u origin main

On the Koyeb control panel, click the DEPLOY MY FIRST APP button to go to the App creation page.

Select GitHub as the deployment method to use
In the repositories list, select the repository containing your Koa application
Specify the branch to deploy, in this case, main
In the Environment variables section, add an environment variable DATABASE_URL having for value your Aiven connection string of form: mysql://AIVEN_DB_USER:AIVEN_DB_PASSWORD@AIVEN_DB_HOST:AIVEN_PORT/AIVEN_DB_DATABASE_NAME?ssl-mode=REQUIRED
Give your App a name, i.e koa-prisma-notes-api-on-koyeb, and click Create App.

There is no need to set the build and run commands, by default Koyeb detects if a build and start scripts are present in your package.json file and execute them automatically.
The build script will be run during the build stage and the startscript to launch the application once the build succeeded.

You land on the deployment page where you can follow the progress of your application's deployment. Once the build and deployment are completed, you can access your application by clicking the App URL ending with koyeb.app in the Koyeb control panel.

Conclusion

That's it! In this tutorial, we looked at how to build a REST API with Koa, Prisma, and Aiven. We created a MySQL database using Aiven, created a new Koa application, and used Prisma to interact with our MySQL database from our application.
Along the line, we covered how to run migration and seed our database with data using Prisma.

Finally, we deployed the application on Koyeb using git-driven deployment: all the changes you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform.
With the Koyeb continuous deployment feature, your changes will go live as soon as the deployment passes all necessary health checks. In case of a failure during deployment, the platform maintains the latest working deployment in production to ensure your application is always up and running.

You can access the complete application code on GitHub.

Deploy a Go Gin Application on Koyeb

Edouard Bonlieu — Wed, 12 Jan 2022 13:26:21 +0000

This guide explains how to deploy a Golang Gin application on the Koyeb serverless platform using git-driven deployment.

Gin is a web framework written in Golang focusing on performance and simplicity.

By deploying a Go Gin application on Koyeb using git-driven deployment, each time you push your code changes, your application will be automatically built and promoted once the built and health checks are completed.
Once your application is deployed, it will benefit from Koyeb native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network with zero configuration.

Requirements

To successfully follow and complete this guide, you need:

The Go programming language installed
A Koyeb account to deploy and run the Go web API
A GitHub account

Steps

To successfully complete this guide and deploy the Go API on Koyeb, you need to follow these steps:

Building a minimalist Go Gin application
Deploy the Go Gin application on Koyeb

Building a minimalist Go Gin application

To get started, create a new directory to build our sample application:

mkdir ~/gin-demo
cd ~/gin-demo

Next, run go mod init to create a go.mod file and track your code's dependencies.
As you add dependencies, the go.mod file will list the versions your code depends on allowing you to keep your builds reproducible and giving you direct control over which module versions to use.

In your project folder, create a new file named app.go with the following content inside:

package main

import (
  "fmt"
  "os"

  "github.com/gin-gonic/gin"
)

func main() {
  port := os.Getenv("PORT")

  if port == "" {
    port = "8000"
  }

  r := gin.Default()

  r.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "Hello, world!",
    })
  })

  r.GET("/:name", func(c *gin.Context) {
    name := c.Param("name")

    c.JSON(200, gin.H{
      "message": fmt.Sprintf("Hello, %s!", name),
    })
  })

  r.Run(fmt.Sprintf(":%s", port))
}

The code above launches a Gin server listening on port 8000 by default with two API routes configured:

/ returning "Hello, world!"
/:name returning "Hello, :name!" where :name is the string passed in parameter, i.e /john will return "Hello, john!".

Then, in your terminal execute go mod tidy to add missing modules required by our project and add github.com/gin-gonic/gin as a project dependency.

You can now run the application locally by running go run server.go and navigating in your browser at http://localhost:8000.

Deploy the Go Gin application on Koyeb

Next, initialize a new git repository on your local machine running:

git init

Add a new remote pointing to your GitHub repository:

git remote add origin git@github.com:<YOUR_GITHUB_USERNAME>/<YOUR_GITHUB_REPOSITORY>.git

Last, add the app.go, go.mod and go.sum files to your repository and commit & push your changes:

git add app.go go.mod go.sum
git commit -m "Initial commit"
git push -u origin main

Go to the Koyeb Control Panel and click the Create App button to go to the App creation page:

Select GitHub as the deployment method to use
In the repositories list, select the repository containing your Go Gin application
Specify the branch to deploy, in this case, main
Give your App a name, i.e go-gin-on-koyeb, and click Create App.

Then, click the Create App button to create and deploy the application. You land on the deployment page where you can follow the progress of your Go Gin application's deployment. Once the build and deployment are completed, you can access your application by clicking the App URL ending with koyeb.app in the Koyeb control panel.

If you want to learn about how Koyeb automatically builds your Go Gin applications from git, make sure to read our how we build from git documentation.

Conclusion

In this guide, you learned how to deploy a Go Gin application on Koyeb using git. Each change you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform.
Your changes then go live as soon as the deployment passes all necessary health checks. In case of a failure during one of your deployments, we ensure to keep the latest working deployment active so your application is always up and running.

If you have any questions or suggestions to improve this guide, feel free to reach out to us on Slack.

Deploy a Laravel Application with Continuous Deployment on Koyeb

Edouard Bonlieu — Mon, 10 Jan 2022 17:13:54 +0000

Introduction

Laravel is a popular, simple and flexible PHP application framework that is ideal for modern, full-stack web apps.

Laravel provides a great developer experience with its many built-in features like dependency injections, an expressive database abstraction layer, queues and scheduled jobs, unit and integration testing, and more.

In this guide, we create a basic Laravel application, push it to a GitHub repository, and deploy it on the Koyeb Serverless Platform using git-driven deployment which allows you to push your code without having to take care of the build, deployment, and run process. Koyeb handles all this for you.

By deploying your Laravel application on Koyeb, you benefit from the platform's built-in autoscaling, autohealing, TLS encryption, global load balancing across our edge network, service discovery, and more.

If you want to learn how to Dockerize and Deploy a Laravel Application to Production, make sure to check out the linked guide.

Requirements

To follow and complete this guide successfully, you need:

A Koyeb account to deploy and run the Laravel web application
The Koyeb CLI installed to interact with Koyeb from the command line
A GitHub account
PHP and Composer installed on your machine

Steps

To deploy a Laravel web application on the Koyeb serverless platform, you need to follow these three steps:

Create a new Laravel application
Push the Laravel application to a GitHub repository
Deploy the Laravel application on Koyeb

Create a new Laravel application

To get started, we will create a new Laravel project using Composer, a PHP package manager. In your terminal, run the following command:

composer create-project --prefer-dist laravel/laravel laravel-on-koyeb

This command will create a new Laravel application in the laravel-on-koyeb directory and install all the dependencies required by the app to run properly.

You can launch the application in development mode by running the following command in your terminal from the laravel-on-koyeb directory:

php artisan serve

Open a browser window and navigate to the http://localhost:8000 URL. You land on the Laravel welcome page.

Generate a key for Laravel's encryption services

Generate an APP_KEY to properly secure user sessions and other encrypted data by running:

php artisan key:generate --show

Save this value in a safe place. We will pass it to Koyeb as an ENV_VAR when we deploy the Laravel app on the platform later.

Add a Procfile

A Procfile tells Koyeb how to run your application. Create a Profile in your application's root directory by executing:

echo "web: vendor/bin/heroku-php-apache2 public/" > Procfile

Push the Laravel application to a GitHub Repository

Now that we have created our Laravel application, we will create a git directory to store it. Return to your laravel-on-koyeb directory and initialize a new git directory for your Laravel project:

git init

Add a .gitignore file

To keep only the necessary files in the repository, add this .gitignore file to exclude all unnecessary Laravel files.

curl https://raw.githubusercontent.com/github/gitignore/master/Laravel.gitignore > .gitignore

Execute the following command to add and commit the changes made in your files to your repository:

git add .
git commit -m "Laravel app initial commit"

Then add these changes to your remote GitHub repository for this app.

git remote add origin git@github.com:YOUR_GITHUB_USERNAME/laravel-on-koyeb.git

Rename the repository default branch to main executing:

git branch -M main

Next, push your changes to the GitHub repository by running:

git push -u origin main

You are now ready to deploy your application on Koyeb.

Deploy the Laravel application on Koyeb

Go to the Koyeb Control Panel and click the Create App button.

On the App Creation form, select GitHub as your deployment method.
Under Repository, select your laravel-on-koyeb repository and specify the Branch. For this demo, put main.
Thanks to your Procfile, there is no need to specify a Run command. Since this is a basic app, you can use the default settings for container size, regions, horizontal scaling, and port.
Add an environment variable Secret with the key as APP_KEY and the value as the value you generated in the step above.
Finally, give your App a name, i.e laravel-on-koyeb, and click Create App.

You land on the deployment page of your service where you can follow the progress of your Laravel application's deployment. Koyeb is building and deploying your application. Once the build and deployment are completed, you can access your application by clicking the App URL ending with koyeb.app in the Koyeb control panel.

If you want to learn about how Koyeb automatically builds your Laravel applications from git, make sure to read our how we build from git documentation.

Your Laravel application is now running on Koyeb and benefits from native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network.

Conclusion

In this guide, you learned how to deploy a Laravel application on Koyeb and benefit from its built-in continuous deployment pipeline. Each change you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform.

Your changes then go live as soon as the deployment passes all necessary health checks. In case of a failure during one of your deployments, we ensure to keep the latest working deployment active so your application is always up and running.

If you have any questions or suggestions to improve this guide, feel free to reach out to us on Slack.

Continuous Deployment of a NestJS Application on Koyeb

Edouard Bonlieu — Wed, 10 Nov 2021 08:39:30 +0000

Introduction

NestJS is a Node.js framework to build efficient and scalable server-side applications. Nest uses and abstracts ExpressJS under the hood to ease development but keeps its API accessible to developers.
This allows you to compose and use all Express's compatible third-party modules and middlewares. In addition to Express, you can also configure Nest to use Fastify, another popular Node.js framework.
Nest is built with typescript and combines the use of object-oriented programming, functional programming, and functional reactive programming.

In this tutorial, we will create a minimalist NestJS application and showcase how to deploy the application with continuous deployment on Koyeb.
By deploying the Nest application on Koyeb using the git-driven deployment method, each time you push new changes to your GitHub repository, a new deployment will occur and be promoted once the built and health checks are completed.

Thanks to Koyeb, you will benefit from native global load-balancing across our edge network, autoscaling, automatic HTTPS (SSL), and auto-healing with zero configuration.

Requirements

To successfully follow and complete this guide, you need:

A local development environment with Node.js installed
A GitHub account
A Koyeb account to deploy and run the Nest application

Steps

To successfully complete this tutorial and deploy the Nest application on Koyeb Serverless Platform, you need to follow these steps:

Create and configure the Nest application
Push the sources to GitHub
Deploy the Nest app on Koyeb

Create and configure the Nest application

Installing the NestJS CLI

To get started, we need to install the Nest CLI. In your terminal run the following command:

npm i -g @nestjs/cli

Create a new Nest application

The Nest CLI installed, we can initialize a new Nest app running:

nest new nestjs-on-koyeb

The command below created a directory nestjs-on-koyeb containing the node modules to properly run the Nest application and a few other boilerplate files.

.
├── README.md
├── nest-cli.json
├── node_modules
├── package-lock.json
├── package.json
├── src
│   ├── app.controller.spec.ts
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── test
│   ├── app.e2e-spec.ts
│   └── jest-e2e.json
├── tsconfig.build.json
└── tsconfig.json

Configuring the Nest application

By default, the Nest listens on port 3000. There are many cases you will want the application to listen on a different port.
Replace the line below to allow setting up the port via the PORT environment variable or use the port 3000 if no environment variable is provided in the src/main.ts file.

main.ts is the entry file of the application which uses the core function NestFactory to create a Nest application instance.

PRISM_DELETED await app.listen(3000);
PRISM_INSERTED await app.listen(process.env.PORT || 3000);

Then, open and edit the package.json file to specify the npm and node versions to use. Here we use the Node LTS version and the latest NPM version:

  ...
  "engines": {
    "node": "14.x",
    "npm": "7.x"
  },
  ...

Push the sources to GitHub

Once the edits are performed, we can commit and push our application to a GitHub repository. When we previously ran the nest new nestjs-on-koyeb command, a git repository has been initialized so we don't need to run git init inside our application directory.

Add the Nest application sources:

git add .
git commit -m "Nest app initial commit"

Add a new remote pointing to your GitHub repository:

git remote add origin git@github.com:<YOUR_GITHUB_USERNAME>/<YOUR_GITHUB_REPOSITORY>.git

Rename the repository default branch to main running:

git branch -M main

Push your changes to the GitHub repository:

git push -u origin main

Deploy the Nest app on Koyeb

On the Koyeb Control Panel, click the Create App button. You land on the App creation page.

Select GitHub as the deployment method to use
In the repositories selector, select the repository containing your Nest application sources
Specify the branch to deploy, in my case I will deploy the main branch.
To let Koyeb how to launch the Nest application, add npm run start:prod as the run command. This will launch the application in production mode.
In the environment variables section, add a new entry with the name NODE_ENV and production as value.
Then, give your App a name, i.e koyeb-nestjs-demo, and click Create App.

You land on the deployment page where you can follow the build of your Nest application. Once the build is completed, your application is being deployed and you will be able to access it via <APP_NAME>.<ORG_NAME>.koyeb.app.

If you want to learn about how Koyeb automatically builds your applications from git, make sure to read our how we build from git documentation.

In this guide, we showcased how Koyeb simplifies the deployment of a NestJS application. With minimal effort, you have a complete, production-ready environment with native global load-balancing, TLS encryption, autoscaling, autohealing, and more to run your Nest application.

Continuously deploy a Flask App using Gunicorn on Koyeb

Edouard Bonlieu — Mon, 18 Oct 2021 12:26:10 +0000

Introduction

Flask is a lightweight web framework written in Python that offers developers powerful tools and features to create web applications with ease and flexibility.

This guide demonstrates how to deploy a Flask application using Gunicorn on the Koyeb Severless Platform. You will create a "Hello World" Flask application, push your code to a GitHub repository, and then deploy your application on the Koyeb platform using its git-driven deployment.

With Koyeb's git-driven deployment, your application benefits from a built-in continuous deployment pipeline because each git push you make to your repository automatically triggers a new build and deployment for your application on the Koyeb Serverless Platform.

For those who prefer deploying Docker containers, we also published a guide explaining how to dockerize and deploy a Python Flask application on the Koyeb Serverless Platform.

Requirements

To successfully follow and complete this guide, you need:

A Koyeb account to deploy and run your Python Flask application
Python installed on your computer
A GitHub account

Steps

To successfully create and deploy Flask application on Koyeb using git-driven deployment, you will need to follow these steps:

Create a Flask application
Deploy the Flask application on Koyeb

Create a Flask application

Begin by creating a directory where our application will live and moving into it by running the following commands:

mkdir flask-on-koyeb
cd flask-on-koyeb

Create a virtual environment

Next, we will create a virtual environment, also known as virtualenv. Virtual environments allow you to create an isolated Python environment to avoid interfering with Python's system packages or other virtual environments.

To create a virtual environment, execute:

python3 -m venv ~/.venv/flask-app

This command creates a new directory flask-app in the ~/.venv directory. The virtualenv contains a copy of the Python interpreter, pip, the standard library, and various supporting files.

To activate the virtualenv we just created, run:

source ~/.venv/flask-app/bin/activate

The virtualenv python and pip executables are now added into your shell’s PATH.

Install Dependencies

Next, install the dependencies required to run the application. In this case, we need Flask and Gunicorn. Flask is the lightweight Python framework we are using for this application and Gunicorn is a web server gateway interface (WSGI) server implementation used to run Python web apps. Gunicorn is a high-performing server better suited for production traffic.

pip install Flask Gunicorn # Install Flask and Gunicorn
pip freeze > requirements.txt # Create the requirements.txt to store the dependencies and version of each package required to run our application.

Create the Flask application

In your flask-on-koyeb directory, create a new app.py file with the following:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == "__main__":
    app.run()

This file is storing our Flask application code. In the snipper above, we define a route to handle / requests and return Hello, World! as a response.

Check to see if the application is working locally by running:

python3 app.py

In your browser, go to http://localhost:5000 and you will see Hello, World!.

Create a git directory for the Flask application

Now that we have created our Flask application, we will create a git directory to store it.

Initialize a new git directory for your Flask project by running the following in your terminal:

git init

To keep only the necessary files in the repository, add this .gitignore file to exclude unnecessary files.

curl https://raw.githubusercontent.com/github/gitignore/master/Python.gitignore > .gitignore

Next, execute the following command to add your files and commit the changes to your repository:

git add .
git commit -m "Flask app initial commit"

Open a new tab in your browser and go to GitHub. Create a new repository named flask-on-koyeb and click the Create repository button. Then, go back to your terminal and add GitHub as a remote repository by running:

git remote add origin git@github.com:YOUR_GITHUB_USERNAME/flask-on-koyeb.git

Rename the repository default branch to main executing:

git branch -M main

Next, push your changes to the GitHub repository by running:

git push -u origin main

Now, you are ready to deploy your application on Koyeb.

Deploy the Flask application on Koyeb

On the Koyeb Control Panel, click the Create App button.

In the form, select GitHub as your deployment method.
Under Repository, select your repository and specify the Branch. For this demo, put Main.
Specify gunicorn app:app for your Run command to let Koyeb know how to launch your application.
Then, give your App a name, i.e koyeb-flask-demo, and click Create App.

Note: You can add more regions, change the instance size, set environment variables, and define horizontal scaling according to your needs.

You land on the deployment page of your service where you can follow the progress of your Flask application's deployment. Koyeb will take care to build and deploy your application. Once these steps are completed, you can access your application by clicking your App URL ending with koyeb.app in the Koyeb control panel.

If you want to learn about how Koyeb automatically builds your applications from git, make sure to read our how we build from git documentation.

Your Flask application is now running on Koyeb and benefits from native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network.

Conclusion

In this guide, you learned how to deploy a Flask application on Koyeb and benefit from its built-in continuous deployment pipeline. Each change you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform. Your changes then go live as soon as the deployment passes all necessary health checks. In case of a failure during one of your deployments, we ensure to keep the latest working deployment active so your application is always up and running.

Other great benefits to deploying your Python Flask application on Koyeb include the platform's built-in autoscaling, automatic HTTPS (SSL), high availability, global load-balancing and edge network.

All of these features and more work out-of-the-box and from the getgo. You focus on your code while Koyeb handles all the necessary underlying infrastructure to keep your services scalable, high performing and available.

Give Koyeb a try with your application! If you have any questions or suggestions to improve this guide, feel free to reach out to us on Slack.

How to Deploy a Python Django Application using PlanetScale and Koyeb Serverless Platform

Edouard Bonlieu — Fri, 10 Sep 2021 07:17:52 +0000

Introduction

Django is a popular and powerful framework for Python application developers. Django comes with many features like authentication, content administration, an Object-Relational Mapper (ORM), and much more.
Django supports various relational databases including MySQL which makes it possible to run a Django application using the PlanetScale database serverless platform without having to perform any changes in your application.

In this guide, we will create a Django application, configure our project to use a PlanetScale database, and deploy the application on the Koyeb Serverless Platform using git-driven deployment.

Using Koyeb git-driven deployment, your Koyeb application is linked to your GitHub repository and each time changes are pushed to your repository, your application is being redeployed automatically by Koyeb.

At the end of this guide, you will have a working Django application running on Koyeb.

Requirements

To successfully deploy a Django application on Koyeb, you need:

Python installed on your machine
A Koyeb account to deploy and run the Django application
A PlanetScale account to run the database our application will use
A GitHub account to store your application code and deploy your application on Koyeb via GitHub

Steps

To complete this guide to have a Django application running on Koyeb, you need to follow these steps:

Create a virtual environment
Create a new Django application
Configure Django to use a PlanetScale database
Deploy the Django application on Koyeb

Create a virtual environment

Before creating the Django application, we will create a virtual environment also known as a virtualenv. Virtual environments allow you
to create an isolated Python environment to avoid interfering with the Python's system packages or other virtual environments.

To create a new virtual environment that we will use for our Django application, in your terminal run:

python3 -m venv ~/.venv/django-app

This command creates a new folder django-app in the ~/.venv directory. The virtualenv contains a copy of the Python interpreter, pip, the standard library, and various supporting files.

We can now activate the virtualenv we previously created by running:

source ~/.venv/django-app/bin/activate

Once the virtualenv is activated, the virtualenv python and pip executables are added into your shell’s PATH.

Create a new Django application

Let's start by creating a dedicated folder for our app and moving into it:

mkdir django-on-koyeb
cd django-on-koyeb

Before creating our Django application, we need to install:

django, to install the Django framework and libraries
dj-database-url, a Django utility that allows to parse DATABASE_URL.
gunicorn, a pure-Python HTTP server for WSGI applications that can run multiple Python concurrent processes
mysqlclient, the librairies to use MySQL or in our case Planetscale

mysqlclient requires system librairies, please check
https://pypi.org/project/mysqlclient/ for detailled instructions

In your terminal, execute the following commands to install the packages locally and save
these dependencies.

pip install django gunicorn dj_database_url mysqlclient
pip freeze > requirements.txt

Once the previous step is completed, you can create the Django application in
our local directory by running:

django-admin startproject django_on_koyeb ./

This command creates a django_on_koyeb directory in your current directory containing the following files:

├── django_on_koyeb
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Prepare the Django application for production

Next, we will edit the settings.py file as we need to customize settings
related to security and performance for
our development and production environment.

Open the settings.py using your favorite editor, here nano:

nano django_on_koyeb/settings.py

We will edit the settings.py file to load some important settings of our application using environment variables.
To access and read environment variables, we need to import the os module.

+import os
from pathlib import Path

Django also requires a SECRET_KEY. This key is used to provide cryptographic signing and should be set to a unique, unpredictable value.
By default, we will want to generate a random secret key when nothing is passed as an environment variable, i.e. when you are running in development mode.

To generate a random secret key, we will need to import from django.core.management.utils import get_random_secret_key:

import os
+from django.core.management.utils import get_random_secret_key
from pathlib import Path

Search for the SECRET_KEY = ... line in the settings.py file and replace it as below:

SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', get_random_secret_key())

Now, when the DJANGO_SECRET_KEY environment variable is set, our application will use it. If no value is provided, the get_random_secret_key() function is called and will return a random secret key.

By default, the Django application runs in DEBUG. When deploying the application in production, for security and performance purposes DEBUG mode needs to be disabled. We will change the default value to disable DEBUG until it is explicitly enabled via the environment variable DJANGO_DEBUG=True.

DEBUG = os.environ.get('DJANGO_DEBUG', 'False') == 'True'

Next, update the ALLOWED_HOSTS directive to read the DJANGO_ALLOWED_HOSTS from the environment. ALLOWED_HOSTS is required to contain the list of strings representing the host/domain names that the Django application can serve.

ALLOWED_HOSTS = os.getenv("DJANGO_ALLOWED_HOSTS", "localhost,127.0.0.1").split(",")

Last, go to the bottom of the file and add the following directive below STATIC_URL:

STATIC_URL = '/static/'
+STATIC_ROOT = os.path.join(BASE_DIR, "staticfiles")

This setting is used to set the directory from which we want to serve static files.
The first part of the Django configuration is done, we can move to the next step and configure Django to use a PlanetScale database.

Configure Django to use a PlanetScale database

To use a PlanetScale database in our Django application, create a new database
from the PlanetScale control panel or using the
CLI running:

pscale database create django-on-koyeb

Once the database is created, create a new database password for the main branch. On the PlanetScale control panel, click the Connect button and new password to generate a user and password to connect the database.
You can also perform this action using the PlanetScale CLI by running:

pscale password create django-on-koyeb main production-password

Keep these credentials in a safe place, we will need them when deploying our application on Koyeb.

On PlanetScale, the main database's schema is immutable and all changes must occur on a development branch. As we will need to perform a migration propagate our models into our PlanetScale database,
we need to create a new branch.

On the PlanetScale control panel, click the New branch button and name the branch migration. You can also perform this operation using the PlanetScale CLI running:

pscale branch create django-on-koyeb migration

Once the branch is created, create a new database password to access the branch. On the PlanetScale control panel, click the Connect button and new password to generate a user and password to connect the database.
You can also perform this action using the PlanetScale CLI by running:

pscale password create django-on-koyeb migration migration-branch-password

As PlanetScale uses Vitess behind the scenes, we need to use a custom database engine to make our Django application work with Vitess.
To retrieve the Vitess custom engine, clone the Vitess repository and copy the custom_db_backends directory in your Django application root folder:

git clone https://github.com/vitessio/vitess.git ~/vitess
cp -r ~/vitess/support/django/custom_db_backends ./

Next, open the Django application settings.py:

nano django_on_koyeb/settings.py

By default, Django is using an SQLite database, we need to edit the
settings.py to use a Vitess database and retrieve the configuration via the DJANGO_DATABASE_URL environment variable.
If the DJANGO_DATABASE_URL is not set, the application will raise the exception DJANGO_DATABASE_URL environment variable not defined when starting.
In the settings.py replace the following part:

# DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.sqlite3',
#         'NAME': BASE_DIR / 'db.sqlite3',
#     }
# }
if os.getenv("DJANGO_DATABASE_URL", None) is None:
    raise Exception("DJANGO_DATABASE_URL environment variable not defined")

DB_PARAMS = dj_database_url.parse(os.environ.get("DJANGO_DATABASE_URL"))
DB_PARAMS["ENGINE"] = "custom_db_backends.vitess"
DATABASES = {
    "default": DB_PARAMS,
}

Let's not forget to import the dj_database_url module we're using:

import os
from django.core.management.utils import get_random_secret_key
+import dj_database_url
from pathlib import Path

You can now save and close the settings.py. Let's run Django migration to propagate the application models to the PlanetScale database. In the terminal run the following command:

DJANGO_DATABASE_URL=mysql://PS_USERNAME:PS_PASSWORD@PS_HOST:3306 python manage.py migrate

Replace the PS_USERNAME, PS_PASSWORD, PS_HOST values with the PlanetScale values you generated for the migration branch.

Then on the PlanetScale control panel, create a new Deploy request to propagate the schema changes performed on the migration branch to the production branch main and deploy it. You can also perform this operation using the PlanetScale CLI by running:

pscale deploy-request create django-on-koyeb migration
pscale deploy-request deploy django-on-koyeb 1

The application is now configured and ready to be deployed on Koyeb.

Deploy the Django application on Koyeb

As the Django application will be deployed on Koyeb using Git, we need to initialize a new git directory for our Django project.
In your terminal run:

git init

To keep only necessary files in our repository, we will add a .gitignore file to exclude undesired files.

curl https://raw.githubusercontent.com/github/gitignore/master/Python.gitignore > .gitignore

Then, execute the following command to add files to commit to your repository and commit the changes

git add .
git commit -m "Django app initial commit"

Open a new tab in your browser and go to GitHub. Create a new repository named django-on-koyeb and click the Create repository button.
Then, go back to your terminal and add GitHub as a remote repository by running:

git remote add origin git@github.com:YOUR_GITHUB_USERNAME/django-on-koyeb.git

Rename the repository default branch to main executing:

git branch -M main

Last, push your changes to the GitHub repository by running:

git push -u origin main

Everything is now ready to deploy the Django application on Koyeb.

Go to the Koyeb control panel and click the Create App button.
Choose GitHub as a deployment method and choose the repository you previously created in the list and set main as the branch value.

Override the default Run command with the following value to get the application to run properly: gunicorn --worker-tmp-dir /dev/shm django_on_koyeb.wsgi

Then, in the Ports section change the default port from 80 to 8000 which is the default port our application is listening to.

In the Environment variables section:

Add an environment variable of type Secret with DJANGO_DATABASE_URL as the value and in the value section click Create Secret and name your Secret django-db-url and mysql://PS_USERNAME:PS_PASSWORD@PS_HOST:3306 as value. Take care to replace PS_USERNAME, PS_PASSWORD, and PS_HOST with the PlanetScale password information you created for your main production branch.
Create a plaintext environment variable with the name DJANGO_DEBUG and value set to True. We need this to validate our application is running properly as it doesn't contain any routes at the moment.
Create a plaintext environment variable with the name DJANGO_ALLOWED_HOSTS and value set to django-on-koyeb-<KOYEB-ORG>.koyeb.app

Give your App a name, for instance django-on-koyeb and click the Create App button.

Your application is now being built and deployed on the Koyeb serverless platform. Within a few minutes, you will be able to access your application by clicking your App URL: https://django-on-koyeb-<KOYEB-ORG>.koyeb.app.

Conclusion

In this guide, we explained how to deploy a Django application on the Koyeb serverless platform with PlanetScale as the database backend for our application.
By deploying on Koyeb, your Django application is secured with native TLS encryption and benefits from all the Koyeb serverless features including autoscaling, auto-healing, and a high-performance edge network.

Thanks to the git-driven deployment feature offered by Koyeb, each time you push new modifications to your GitHub repository, a new deployment of your application occurs automatically.
This allows you to focus on your application code while Koyeb takes care of building, deploying your application, and ensure your service is always up and running.

If you have any questions or suggestions to improve this guide,
feel free to reach out to us on Slack.

Dockerize, Deploy and Run a Ruby on Rails application on Koyeb

Edouard Bonlieu — Fri, 27 Aug 2021 07:10:57 +0000

Introduction

Ruby on Rails, or Rails, is a popular, server-side model-view-controller (MVC) web framework written in Ruby.
Rails provides all the features you need to build and maintain a modern web application.

Rails follows the convention over configuration philosophy meaning you write less code, and don't have to deal with tons of configuration files so you can focus on your application logic.

In this documentation, we will explain how to dockerize, deploy and run a Ruby on Rails application on the Koyeb serverless platform. By running your application on Koyeb, you natively benefit from
autoscaling, autohealing, TSL encryption, a Global Edge Network CDN, and more.

At the end of this guide, you will have a working Rails application containerized and running on Koyeb.

Requirements

To successfully dockerize and run your Rails application on Koyeb, you need:

Rails installed on your machine
Docker installed on your machine
A Koyeb account to deploy and run the Rails application
The Koyeb CLI installed to interact with Koyeb from the command line
A registry that we will use to store our Rails web app Docker image and deploy it on Koyeb

Steps

To successfully complete this guide to have a Rails application containerized and running on Koyeb, you need to follow these steps:

Create a new Rails application
Dockerize the Rails application
Push the Docker image to a container registry
Deploy the Dockerized Rails app on Koyeb

Create a new Rails application

If you already have an existing Rails application that you want to dockerize and deploy on Koyeb, you can jump to the next step.

To get started, we will create a basic Rails application using the new application generator. The command we will execute creates all the foundation of a fresh Rails application so that you don't have to write it yourself.

In your terminal, run the following command to create a new Rails application:

rails new demo

The command creates a demo directory and installs all the dependencies required to run the application. Once the initialization is done, go to the demo directory and add a new route to the router file config/routes.rb to handle request on /.

Rails.application.routes.draw do
  root 'hello_world#index'
end

The route above is used to indicate GET / requests are mapped to the index action of HelloWorldController.
To create the HelloWorldController and its index action, run:

rails generate controller HelloWorld index --skip-routes

As you can see, we pass the --skip-routes as we don't want to generate a route for this controler as we previously manually created one.
Now, you can launch the development server running:

$rails server
=> Booting Puma
=> Rails 6.1.4 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 5.4.0 (ruby 2.6.1-p33) ("Super Flight")
*  Min threads: 5
*  Max threads: 5
*  Environment: development
*          PID: 28869
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop

Request on / will be handled by our HelloWorld controller. You can open a browser window and navigate to the http://localhost:3000 URL. You land on the HelloWorld application page.

Dockerize the Rails application

To Dockerize the Rails application, create a Dockerfile in your project root directory and copy the content below:

FROM ruby:3-alpine
WORKDIR /app
COPY . .
RUN apk add --no-cache build-base tzdata nodejs yarn sqlite-dev postgresql-dev mysql-dev
RUN gem install bundler
RUN bundle install
ENV RAILS_ENV=production
RUN bundle exec rails assets:precompile
EXPOSE 3000
CMD ["rails", "server", "-b", "0.0.0.0"]

Build the Docker image by running:

docker build . -t ghcr.io/<GITHUB_USERNAME>/rails-app

In this guide we will push the Docker image to the GitHub container registry. You are free to use another registry as Koyeb allows you to deploy from any container registry.

Once the build is finished, you can run a container locally with the image to validate everything is working as expected using:

docker run -p 3000:3000 ghcr.io/<GITHUB_USERNAME>/rails-app

Your container should start and you can test the routes using curl:

curl localhost:3000/

Push the Docker image to a container registry

Now that the Docker image is built and working properly, we can push it to a container registry. In this guide we will use the GitHub container registry. In your terminal run the command below to push the image:

docker push ghcr.io/<GITHUB_USERNAME>/rails-app

Your Docker image is now available on the GitHub container registry: https://github.com/<YOUR_GITHUB_USERNAME>?tab=packages.

Deploy the Dockerized Rails web app on Koyeb

You can now deploy the dockerized Rails application on Koyeb. This section explains how to deploy on the Koyeb serverless platform using the CLI. This operation can also be performed using the control panel.

First, we need to create a Koyeb Secret containing the GitHub container registry configuration to deploy private images. In your terminal execute the following command and replace <REPLACE_ME_WITH_GH_USERNAME> with your GitHub username and <REPLACE_ME_WITH_GH_TOKEN> with a valid GitHub token having registry read/write permissions and execute the command below.

echo \
'{
  "auths": {
    "ghcr.io": {
      "username": "<GITHUB_USERNAME>",
      "password": "<GITHUB_TOKEN>"
    }
  }
}' | koyeb secrets create docker-hub-credentials --value-from-stdin

We can now deploy the Rails application on Koyeb Serverless Platform running:

koyeb app init rails-app --docker "ghcr.io/<REPLACE_ME_WITH_GH_USERNAME>/rails-app" --ports 3000:http --routes /:3000 --docker-private-registry-secret gh-registry-credentials

Within a few minutes, your application will be live and accessible at https://rails-app-<KOYEB-ORG>.koyeb.app.

Conclusion

In this guide, we explained how to containerize, deploy and run a Rails application on Koyeb.
By deploying on Koyeb, your Rails application is secured with native TLS encryption and benefits from all the Koyeb serverless features including autoscaling, auto-healing, and a high-performance edge network.

If you have any questions or suggestions to improve this guide,
feel free to reach out to us on Slack.

Deploy a RESTful Go API with Gin on Koyeb

Edouard Bonlieu — Tue, 24 Aug 2021 16:09:12 +0000

In this guide, we will explain how to build and deploy a Go API using the Gin framework on the Koyeb serverless platform.

Gin is a web framework written in Go focusing on performance. It provides an elegant way to write web applications and microservices and comes with a set of commonly used primitives like routing, middleware, rendering, and more.

By deploying your application on Koyeb, you benefit from powerful primitives including native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network with zero configuration.

Requirements

To successfully follow and complete this guide, you need:

The Go programming language installed
Docker installed on your machine
A Koyeb account to deploy and run the Go web API
The Koyeb CLI installed to interact with Koyeb from the command line
Have a registry that we will use to store our Go web app Docker image and deploy it on Koyeb

Steps

To successfully complete this guide and deploy the Go API on Koyeb, you need to follow these steps:

Building the Go API using Gin
Dockerize the Go application
Deploy the Dockerized Go API on Koyeb

Building the Go API using Gin

First, let's get started by creating a new directory in your GOPATH to build our sample application:

mkdir $GOPATH/src/go-demo
cd $GOPATH/src/go-demo

In this guide, we name the directory go-demo. You can name the folder whatever you like.

Next, run go mod init to create a go.mod file and track your code's dependencies. As you add dependencies, the go.mod file will list the versions your code depends on allowing you to keep your builds reproducible and gives you direct control over which module versions to use.

In your project folder, create a new file named server.go with the following content inside:

package main

import (
    "fmt"
    "os"

    "github.com/gin-gonic/gin"
)

func main() {
    port := os.Getenv("PORT")

    if port == "" {
        port = "8000"
    }

    r := gin.Default()

    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, world!",
        })
    })

    r.GET("/:name", func(c *gin.Context) {
        name := c.Param("name")

        c.JSON(200, gin.H{
            "message": fmt.Sprintf("Hello, %s!", name),
        })
    })

    r.Run(fmt.Sprintf(":%s", port))
}

The code above launch a Gin server listening on port 8000 by default with two API routes configured:

/ returning "Hello, world!"
/:name returning "Hello, :name!" where :name is the string passed in parameter, i.e /john will return "Hello, john!".

Then, in your terminal execute go mod tidy to add missing modules required by our project and add github.com/gin-gonic/gin as a project dependency.

You can now run the application locally running go run server.go and navigate in your browser at http://localhost:8000.

Dockerize the Go application

To Dockerize our Go application, create a Dockerfile in your project directory.
In this guide, we use Docker multi-stage build to keep the image layers size as small as possible and to ensure our image contains only what is needed to run.

In your Dockerfile, copy the content below:

FROM golang:1.16-alpine AS builder
WORKDIR /app
COPY . .
RUN go mod download
RUN go build -o ./go-demo ./server.go


FROM alpine:latest AS runner
WORKDIR /app
COPY --from=builder /app/go-demo .
EXPOSE 8000
ENTRYPOINT ["./go-demo"]

The first stage is used to install dependencies and build our application, in the second one we copy the application binary from stage one and use it to run the application.

To build the Docker image execute the following command in your terminal:

docker build . -t <DOCKER_HUB_USERNAME>/go-demo

In this guide we will push the Docker image to the Docker Hub. You are free to use another different registry as Koyeb allows you to deploy from any container registry.

Once the build is completed, you can run a container using the image locally to validate everything is working as expected running:

docker run -p 8000:8000 <DOCKER_HUB_USERNAME>/go-demo

If everything goes well, your container starts properly, you can test the routes using curl:

$curl localhost:8000/
Hello, world!

Next, we can push the Docker image to a container registry, in this guide, the Docker Hub using the following command:

docker push <DOCKER_HUB_USERNAME>/go-demo

On the push command is completed, the Docker image is stored on the container registry and we can deploy it on Koyeb.

Deploy the Dockerized Go API on Koyeb

We are now ready to deploy our Go web application on Koyeb. First, create a Koyeb Secret to store your container registry configuration.
In this guide, we will deploy our app from the Docker Hub. For other container registries example, check out the related documentation.

Note: if your Docker image is public, there is no need to create a secret containing your container registry configuration.

echo \
'{
  "auths": {
    "index.docker.io/v1/": {
      "username": "<REPLACE_ME_WITH_DOCKER_HUB_USERNAME>",
      "password": "<REPLACE_ME_WITH_DOCKER_HUB_TOKEN>"
    }
  }
}' | koyeb secrets create docker-hub-credentials --value-from-stdin

We can now deploy the Go web application on Koyeb Serverless Platform running:

koyeb app init go-demo --docker "<REPLACE_ME_WITH_DOCKER_HUB_USERNAME>/go-demo" --ports 8000:http --routes /:8000 --docker-private-registry-secret docker-hub-credentials

This command creates a new Koyeb App and deploys our Go application exposing port 8000 and making it publicly accessible on the / route of your Koyeb App URL.

To retrieve your Koyeb App URL and access your application, run:

$koyeb app get go-demo
ID                                      NAME            DOMAINS                                 UPDATED AT
d58ebed1-48c0-46b7-a2f1-91f3ffdbccf2    go-demo         go-demo-<YOUR_ORG>.koyeb.app    2021-06-23 09:46:55.411403 +0000 UTC

Open the URL in your browser to access your application running on Koyeb and natively offering autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network.

Dockerize and Deploy a Laravel Application to Production

Edouard Bonlieu — Thu, 29 Jul 2021 06:23:28 +0000

Introduction

Laravel is a popular, simple and flexible PHP application framework.
Laravel comes with many build features offering a great developer experience such as thorough dependency injection, an expressive database abstraction layer, queues and scheduled jobs, unit and integration testing, and more.

In this guide, we will explain how to dockerize and deploy a Laravel application to production using Docker to containerize our application and deploy it to the Koyeb Serverless Platform.

By deploying your Laravel application on Koyeb, you benefit from native autoscaling, autohealing, TLS encryption, global load balancing across our edge network, service discovery, and more.

Requirements

To successfully follow and complete this guide, you need:

Docker installed on your machine
- A Koyeb account to deploy and run the Laravel web application
- The Koyeb CLI installed to interact with Koyeb from the command line
- Have a registry we will use to store our Laravel web app Docker image and deploy it on Koyeb

Steps

To successfully deploy a Laravel web application on the Koyeb serverless platform, you need to follow these steps:

Create a new Laravel application
Dockerize the Laravel application
Push the Docker image to a container registry
Deploy the Dockerized Laravel web app on Koyeb

Create a new Laravel application

If you already have an existing Laravel application you want to dockerize and deploy on Koyeb, you can jump to the next step.

To get started, we will create a new Laravel project using Composer, a PHP package manager. In your terminal, run the following command:

composer create-project --prefer-dist laravel/laravel laravel-demo

This command will create a new Laravel application in the laravel-demo directory and install all the dependencies required by the app to run properly.

You can launch the application in development mode by running the following command in your terminal from the laravel-demo directory:

php artisan serve

Open a browser window and navigate to the http://localhost:8000 URL. You should see the Laravel welcome page.

Dockerize the Laravel application

With our minimalistic Laravel application ready, we can now create the Dockerfile that we will use to containerize our Laravel application.

We will use the webdevops/php-nginx:7.4-alpine as the base image which provides Nginx with PHP-FPM installed and configured. The image can be customized depending on your needs. You can read the full documentation here.
In your application directory, create a new file named Dockerfile and paste the following code:

FROM webdevops/php-nginx:7.4-alpine

# Install Laravel framework system requirements (https://laravel.com/docs/8.x/deployment#optimizing-configuration-loading)
RUN apk add oniguruma-dev postgresql-dev libxml2-dev
RUN docker-php-ext-install \
        bcmath \
        ctype \
        fileinfo \
        json \
        mbstring \
        pdo_mysql \
        pdo_pgsql \
        tokenizer \
        xml

# Copy Composer binary from the Composer official Docker image
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

ENV WEB_DOCUMENT_ROOT /app/public
ENV APP_ENV production
WORKDIR /app
COPY . .

RUN composer install --no-interaction --optimize-autoloader --no-dev
# Optimizing Configuration loading
RUN php artisan config:cache
# Optimizing Route loading
RUN php artisan route:cache
# Optimizing View loading
RUN php artisan route:cache

RUN chown -R application:application .

As you probably noticed, we don't specify the CMD to tell Docker how to run our container.
This is because the base image FROM webdevops/php-nginx:7.4-alpine run the Nginx and PHP-FPM in the foreground and we inherit this command.

If your application requires additional php extensions, you can install them using the docker-php-ext-install command.

In this guide we will push the Docker image to the Docker Hub. You are free to use another different registry as Koyeb allows you to deploy from any container registry.

To build the image run the following command and replace <DOCKER_HUB_USERNAME> with your own.

docker build -t <DOCKER_HUB_USERNAME>/laravel-demo .

Once the build is complete, you can run the image locally to ensure everything is working as expected.

docker run --rm -t -p 9000:80 <DOCKER_HUB_USERNAME>/laravel-demo

Push the Docker image to a container registry

Now that we have our Docker image ready, we can push it to the Docker Hub by running:

docker push <DOCKER_HUB_USERNAME>/laravel-demo

Once the image is successfully pushed to the Docker Hub, we can use it to deploy the Laravel application on Koyeb.

Deploy the Dockerized Laravel web app on Koyeb

With the previous steps completed, we can now deploy our application on production to Koyeb.
This section explains how to deploy on the Koyeb serverless platform using the CLI. This operation can also be performed using the control panel.

First, we need to create a Koyeb Secret containing the Docker Hub configuration to deploy private images. In your terminal execute the following command and replace <DOCKER_HUB_USERNAME> and <DOCKER_HUB_TOKEN>
with your own.

echo \
'{
  "auths": {
    "index.docker.io/v1/": {
      "username": "<DOCKER_HUB_USERNAME>",
      "password": "<DOCKER_HUB_TOKEN>"
    }
  }
}' | koyeb secrets create docker-hub-credentials --value-from-stdin

We can now deploy the Laravel application by running:

koyeb app init laravel-demo --docker "<DOCKER_HUB_USERNAME>/laravel-demo" --docker-private-registry-secret docker-hub-credentials

This command creates a new Koyeb App and deploy the Laravel application using the Docker image. To retrieve your Koyeb App URL and access your application, run:

$koyeb app get laravel-demo
ID                                      NAME            DOMAINS                                 UPDATED AT
d58ebed1-48c0-46b7-a2f1-91f3ffdbcccc    laravel-demo    laravel-demo-<YOUR_ORG>.koyeb.app       2021-06-28 12:46:55.411403 +0000 UTC

Open the URL in your browser to access your application running on Koyeb.

This guide shows how easy it is to deploy your Laravel application in production using Docker and Koyeb.
Thanks to Koyeb native global load balancing edge network, your content is distributed near your users and your app comes with native TLS encryption.

To learn more about what Koyeb has to offer, check out the features page.

The Koyeb Serverless Engine: from Kubernetes to Nomad, Firecracker, and Kuma

Edouard Bonlieu — Thu, 08 Jul 2021 10:54:52 +0000

At Koyeb, our mission is to provide the fastest way to deploy applications globally. We are building a platform allowing developers and businesses to easilyrun applications, a platform where you don't need to think and deal with the
resiliency and scalability of your servers: a serverless platform.

Ironically, a serverless platform is actually full of servers. As a cloud service provider, we operate the infrastructure for you and abstract it as much
as possible.

The initial technological choices you make as a cloud service provider are crucial. Not only do they determine the features you can develop, but also the resiliency and scalability of your entire platform.

We decided to build our own serverless engine, one that would not be limited by existing implementations. The first version of Koyeb was built on top of Kubernetes and allowed us to quickly build a working cloud platform. After a few months of operating with this version, we decided to move user workloads from Kubernetes to a custom stack based on Nomad, Firecracker, and Kuma.

We wrote this blog post to explain why we moved from Kubernetes to a custom stack to power our users' serverless workloads. This post is written from our point of view as a cloud service provider.

Koyeb's requirements: Fast, Global, Secure, Scalable
Building on top of the right abstraction layer
The limits of Kubernetes
The stack behind Koyeb Serverless Engine: Nomad, Firecracker, Kuma on BareMetal... and Kubernetes

Koyeb's requirements: Fast, Global, Secure, Scalable

Before diving into the technicals, let me outline the requirements which led us to where we are today.

At Koyeb, we are building a next-generation serverless platform that should be the fastest way to deploy applications globally. There are four core pillars we want to achieve:

Fast: we want the platform to be quick, both when you deploy your application and when the application is running. We believe deploying a software update should take minutes or ideally seconds. No developer wants to wait dozens of minutes before an upgrade is deployed, especially when working on development or pre-production environments. Execution should also be fast and your workloads should not be slower in the cloud than on your laptop.
Global: for businesses, deploying globally is rarely optional in 2021, and it is definitely not an option for us as we have customers all around the world. Whether you're operating a global B2C brand or a B2B company, if you have users all around the world, you need a simple and effective way to operate in multiple regions. Compliance and performance are the two drivers here.
Secure: as a cloud service provider, security is crucial, especially as we operate a multi-tenant environment. Isolation between customers should be reliable, both at the host and network level. From a user perspective, security should be built-in and should not be an option.
Scalable: to be competitive on the market, we need to offer a scalable platform for our end-users and we need to build a platform able to support both your growth and our own growth. We've already experienced the pain of struggling with growth in a previous life. To better support our customers all around the world, we want to be able to run on different cloud service providers depending on locations and to respect sovereignty requirements.

Now that we have a list of requirements, let's move to the technical options.

Building on top of the right abstraction layer

The options

We considered all level of abstractions to build
a full-featured platform which would be able to support our mission and requirements. We had roughly 4 options, below is the list sorted from the highest level of abstraction to the
one where you deal directly with hardware:

Cloud providers primitives: Building on top high-level function and container primitives of cloud providers
Kubernetes: Using Kubernetes to power our user workloads
VMs or BareMetal: Building a purpose-built solution, on top of Virtual Machines or BareMetal servers
Racking: Operating our own physical infrastructure and network (aka racking BareMetal machines)

Our own users face the same kind of options to deploy and operate their production applications. Most of them will rule out options 3 and 4 as these are irrelevant for
most businesses nowadays.
We believe anybody who is not in the infrastructure business should try to build on top of high-level providers like Koyeb, aka option 1.

Our first choice: Kubernetes to the rescue

We quickly ruled out racking servers (option 4). We've been in the business of racking and even building BareMetal servers
before but there are now enough options to pick from, at least for our current needs. In 2021, building software usually involves relying on a cloud service provider. We are no exception to that as we are building a cloud service provider on top of other cloud service providers.

We also ruled out building on top of high-level abstractions of cloud service providers (option 1) since it doesn't provide the control we need.This option would probably allow us to develop features faster, but our platform would suffer from the same product limits as these abstractions. Since our goal is to remove these limits to improve our users' deployment experience, this choice would be counter-productive.

With this in mind, we started to build on top of Kubernetes, believing this would be the right abstraction layer to quickly build a reliable platform meeting our requirements. Spoiler alert, after several months we decided to build a purpose-built solution instead...

The limits of Kubernetes

At Koyeb, we have been operating Kubernetes clusters for two years now and, once we started to support custom user functions and containers, we began to see limits.

Here is a broad overview of the limits we started to hit:

Complexity: Let's start with the most common complaint you might hear: it's complex. In our case, we need to be able to extend the core. Even when operating a cloud platform is your business, understanding how Kubernetes works and why it was implemented this way is hard.
Security: Kubernetes provides some options to isolate multi-tenant serverless workloads. We first worked with gVisor, but the performances were disapointing. We decided to explore using Firecracker but running Firecracker on Kubernetes was experimental.
Global and multi-zone deployments: User workloads on Koyeb need to be able to run in multiple zones. Kubernetes doesn't support multi-zone out of the box. Implementing multi-zone with Kubernetes requires deploying a full cluster per zone, with a dedicated control plane for each data center.
Scalability: Kubernetes is known to have limits in terms of the number of nodes in a cluster, which means that multi-cluster support needs to be implemented really quickly when operating at scale.
Upgradability: Release cycles are really short, which is great but difficult to manage in production. Having to upgrade every two months, which means testing and validating that the upgrades do not break the production quickly becomes a full-time job.
Overhead: Kubernetes clusters tend to have considerable overhead. On each hypervisor, Kubelet uses between 10% and 25% of RAM which is a non-negligible cost. Spoiler alert: We're more around 100MB with our new architecture.

Kubernetes: a generalist orchestration platform

Back in the early 2010s, the hype was more around OpenStack than Kubernetes as Docker didn't even exist, but Kubernetes is the same kind of project: an all-purpose orchestration platform.

In our experience as a cloud service provider, when you work with large general-purpose software projects, you tend to
hit the same issues:

once you start scaling or trying to develop advanced features on such a platform, you need to fully understand the internals
you spend a lot of energy trying to follow upgrades which might not be relevant to you, break your integrations, and you suffer from decisions you have no control over

Don't get me wrong, Kubernetes definitely helped us develop quickly the first generations of the Koyeb engine. The ability to deploy pre-written Helm Charts is a powerful tool to deploy existing software.

As a cloud service provider, we knew we would eventually hit the limits and would either need to deep dive into Kubernetes and contribute inside its core or design the Koyeb platform differently...

The stack behind Koyeb: Nomad, Firecracker, Kuma on BareMetal... and Kubernetes

With all these limits in mind, we started to re-design the platform to support our goals.
After some testing, we decided to build our serverless platform using a combination of powerful technologies. Enter Nomad, Firecracker, and Kuma on BareMetal... and Kubernetes.

Overall architecture

To understand why we combined these technologies, let's take a step back.
On the Koyeb platform, there are two key parts:

the Koyeb Control Plane is composed of the Go APIs behind app.koyeb.com and related databases. It receives the API calls and handles all the logic to effectively deploy the app on the Koyeb Data Plane. It needs to run 24x7x365 with requirements pretty similar to those of users' on Koyeb.
the Koyeb Data Plane hosts the deployed users' applications. It's the core of the platform, it needs to support running millions of containers across thousands of hypervisors. It's the most demanding part of the platform.

On each hypervisor of the data plane, there are 4 major elements:

the container runtime and virtualization technology, Firecracker, effectively executing the applications, ensuring multi-tenants workloads are isolated and secured in a performant fashion
the networking technology, composed of Kuma and Envoy, providing the service mesh and discovery engine which enable seamless private networking between services
the orchestration engine, Nomad, which performs all provisioning operations when a deployment happens or scaling events happen
the operating system and servers, CoreOS on High-End BareMetal servers, where the applications run with the lowest possible overhead

And the Control Plane runs on... Kubernetes. As we cannot run the Koyeb Control Plane on Koyeb to avoid circular dependencies, we run the APIs on top of Kubernetes.

Diving into Nomad, Firecracker, and Nomad

Nomad for Container Orchestration

Nomad is a workload orchestration engine which can be used to manage containers and non-containerized applications across clouds.
Nomad lets us deploy and manage the containerized applications that are running on the platform. It provisions Firecracker microVMs and communicates with containerd to manage and run the containers.

We selected Nomad to do the orchestration because compared to Kubernetes it is:

easily extendable. Runtimes can easily be customized and integrating with Firecracker was seamless using a custom nomad driver.
simpler to use. The scope of the project is way smaller, it doesn't cover everything from runtime to networking and that's just what we needed.
multi-zone out of the box, simplifying how we make serverless workloads global.
easy to implement control plane at the region level, reducing the overhead of per-region Kubernetes clusters.
has a smaller footprint and is easy scalable.

Firecracker for Virtualization

Firecracker is a lightweight virtualization technology that was purpose-built to securely and efficiently run multi-tenant serverless workloads. We needed a virtualization technology that
would keep our clients' workloads secure and isolated, and provides fast boot-up times for new instances without compromising performances. That's exactly what Firecracker does.

We've written about Firecracker MicroVMs in a previous blog post if you want to dive deeper.

The key benefits are:

Multi-tenancy security and isolation,
High density on bare metal machines thanks to low overhead,
Fast boot-times for autoscaling microservices and functions

There are a few more benefits that we go over in detail in our post 10 Reasons Why We Love Firecracker MicroVMs.

Kuma for Service Mesh Control Plane

Kuma is an open-source service mesh built on top Envoy. It is a control plane that connects distributed services running on Kubernernets and VMs.

We built Koyeb to host distributed and microservice architectures. Distributed architectures need a way to connect the services that run within them. A service mesh is the dedicated infrastructure layer that is responsible for the secure, quick, and reliable communication between services in containerized and microservice applications.
For more information about service meshes, check out our post on service meshes and microservices.

Kuma is a rare service mesh that is not tightly coupled to its workload scheduler. This distinguishes it from alternative service meshes like Linkerd and Istio, which only work on Kubernetes. Moreover, Kuma supports multi-zone and cloud-agnostic out of the box.

The Kuma control plane allows us to secure, observe, and manage the microservice network. Next to each service instance on Koyeb is an Envoy Proxy. These proxies form the data plane, which connects to the Kuma control plane.

Proxies are configured from the control plane, meaning the hostnames your instances should know for DNS, their retry policies, and more are all communicated to the proxy from the control plane.

Kuma and Envoy provide us with a great option for private networking, especially because they:

are platform agnostic,
support multi-region and multi-cloud deployments,
can run in a zero-trust network environment thanks to native TLS encryption and mTLS authentication,
provide natively secure communication between services.

The Koyeb Serverless Platform is Purpose-Built

We built Koyeb to be a secure and powerful serverless platform that is developer-friendly. Providing this serverless experience entails running multi-tenant workloads on bare metal servers in a secure and resource-efficient manner.
Moving from Kubernetes to a customized stack of Nomad, Firecracker, and Kuma enables us to provide the serverless experience we envision for the serverless future.

You can use Koyeb to host web apps and services, Docker containers, APIs, event-driven functions, cron jobs, and more. At the moment, the platform has built-in Docker container deployment and git-driven deployment is on the way!

Discover the serverless experience and by signing up today. Also, feel free to join us over on Slack.

And if you want to help build a serverless cloud service provider and dive deeper into these technologies, we're hiring!