You have created an Environment.
An application is part of a Project within an Environment and is a container unit. Multiple applications can be part of the same Environment, be connected to a set of dependencies (databases and other services), and can communicate with other applications within the same Environment.
Create an Application
General settings allow you to set up your application name, git repository and build mode.
- Configure your repository URL (it can be hosted on Github or Gitlab, Bitbucket support coming soon).
- Select branch that Qovery should use for builds in this environment
Root Application Path- base folder in which the application resides in your repository
Option 1: Buildpacks
To simplify the application build for the developer, Qovery supports Buildpacks out of the box. Buildpacks determine the build process for an app and which assets and runtimes should be made available to your code at runtime. If your complex apps are running multiple languages, you can also use multiple buildpacks within a single app.
Meaning, as a developer, you don't need to write a
Dockerfile to build and run your app. Qovery Buildpacks takes care of everything for you.
You don't find a cool language? Suggest us to support it
Option 2: Dockerfile
FROM node:13-alpineRUN mkdir -p /usr/src/appWORKDIR /usr/src/appCOPY . .RUN npm installEXPOSE 3000CMD node ./bin/www
After creating a Dockerfile, specify the location of your Dockerfile in
Dockefile path field.
Configuration from above will make Qovery look for the Dockerfile in
/timescale/Dockerfile path of your repository (
Root Application Path +
To configure the number of CPUs that your app needs, adjust the setting in the
Resources section of the application configuration.
To configure the amount of RAM that your app needs, adjust the setting in
Resources section of the application configuration.
Qovery gives you the power to have multiple apps within one environment. Sometimes it's necessary to one or multiple apps before others.
By using the
Dependency configuration, you can declare a list of apps your app is depending on.
Setting up application dependencies will make sure all the dependencies are running before your application starts.
The default filesystem for applications running on Qovery is ephemeral. Application data isn’t persisted across deploys and restarts, which works just fine for most apps because they use managed databases to persist data.
However, many applications need persistent disk storage that isn’t ephemeral. These include:
- Blogging platforms and CMSs like WordPress, Ghost, and Strapi.
- Collaboration apps like Mattermost, GitLab, and Discourse.
This is where Qovery block Storage comes in. Qovery applications can use storage to store data that persists across deploys and restarts, making it easy to deploy stateful applications.
✅ Good use cases
- For I/O intensive applications (E.g. database)
- To store temporary files
❌ Bad use cases
- To store file > 1 TB
- To expose files from an application (E.g. images)
Types of Block Storage
Qovery Storage supports:
|Type||Max IOPS||Max Throughput||Min Size||Max Size||Use cases|
|fast_ssd||64000||1GB/s||5GB||10GB ||Critical business applications that require sustained IOPS like databases|
You can set up your Block Storage in
Storage section of your application configuration.
Most of the application needs to be accessed by other services inside or outside of your environment. To set up the access, declare the ports your application uses. Internal ports are available internally inside your environment for other services to use. You can also expose ports publicly - it makes them accessible over the public network.
Domain section of your application configuration allows you to define a custom domain for your application.
After setting up a custom domain, you'll see a
Value that you need to set up as a
CNAME record in your domain registrar.
Setting up the
CNAME on the domain provider side will make your app accessible through your custom domain on Qovery.
To access your database in your application, link it to your application in the
Database section of your application configuration.
Linking the database to your app will make sure it's up and running before your application starts. It will also ensure that database secrets and other important information are injected as secrets into your application.
Example of secrets and environment variables injected into your app for the linked database:
"QOVERY_DATABASE_MY_POSTGRESQL_DATABASE": "postgres""QOVERY_DATABASE_MY_POSTGRESQL_PASSWORD": "xxx""QOVERY_DATABASE_MY_POSTGRESQL_USERNAME": "superuser""QOVERY_DATABASE_MY_POSTGRESQL_PORT": "5432""QOVERY_DATABASE_MY_POSTGRESQL_FQDN": "my-postgresq-y1irp3nmdzj32yjl-svc.cnuxtlki1yn9.eu-west-3.rds.amazonaws.com""QOVERY_DATABASE_MY_POSTGRESQL_HOST": "my-postgresq-y1irp3nmdzj32yjl-svc.cnuxtlki1yn9.eu-west-3.rds.amazonaws.com""QOVERY_DATABASE_MY_POSTGRESQL_CONNECTION_URI_WITHOUT_CREDENTIALS": "postgresql://my-postgresq-y1irp3nmdzj32yjl-svc.cnuxtlki1yn9.eu-west-3.rds.amazonaws.com:5432/postgres""QOVERY_DATABASE_MY_POSTGRESQL_CONNECTION_URI": "postgresql://superuser:[email protected].amazonaws.com:5432/postgres""QOVERY_DATABASE_MY_POSTGRESQL_VERSION": "11.5""QOVERY_DATABASE_MY_POSTGRESQL_TYPE": "POSTGRESQL""QOVERY_DATABASE_MY_POSTGRESQL_NAME": "my-postgresql"
The built-in variables follow the naming pattern:
QOVERY_DATABASE + <your_db_name> + <type_of_variable> where:
<your_db_name>is the name of your database
<type_of_variable>is the type of variable we inject, e.g.
CONNECTION_URIand so on.
To learn how to set up environment variables in your projects and applications, navigate to configuring Environment Variables section.
To learn how to set up secrets in your projects and applications, navigate to configuring Secrets section.
To learn how to display your application logs, navigate to logs section in our Debugging guide