Skip to main content

Creating Applications

This guide provides step-by-step instructions for deploying applications on the Thevenin platform within your environments.

Prerequisites​

Before deploying an application, ensure you have:

  • A Thevenin account and access to the dashboard
  • An environment already created (environments must be created before deploying applications)
  • A container image name and tag (e.g., nginx:latest, postgres:14)
  • (Optional) Environment variables and configuration prepared

Step-by-Step Guide​

Step 1: Navigate to Your Environment​

Applications are deployed within environments:

  1. Log in to your Thevenin dashboard
  2. Navigate to Environments from the main menu
  3. Select the environment where you want to deploy your application

Step 2: Start Application Deployment​

  1. Click "Deploy Application" or "New Application" button within the environment

Step 3: Basic Information​

Fill in the basic application details:

Application Name​

  • Required: Yes
  • Format: Lowercase letters, numbers, and hyphens
  • Example: my-web-app, user-service-api
  • Best Practice: Use descriptive names that indicate the application's purpose

Description​

  • Required: No
  • Purpose: Help team members understand what the application does
  • Example: "NGINX web server for static content"

Step 4: Container Configuration​

Container Image​

Specify the container image to run:

Format: image:tag

Examples:

nginx:latest
nginx:1.21
postgres:14
mysql:8
redis:alpine
mongo:latest
node:18-alpine
python:3.11-slim

We recommend to Specify exact tags rather than latest for production environments

Common Images:

Web Servers:

  • nginx:latest - NGINX web server
  • httpd:latest - Apache HTTP server

Databases:

  • postgres:14 - PostgreSQL
  • mysql:8 - MySQL
  • redis:alpine - Redis
  • mongo:latest - MongoDB

Application Runtimes:

  • node:18-alpine - Node.js
  • python:3.11-slim - Python
  • openjdk:17-slim - Java

Port Configuration​

Configure the ports your application exposes:

Container Port: The port your application listens on inside the container

  • Example: 8080, 3000, 80, 5432

Protocol: TCP or UDP (default: TCP)

Common Port Examples:

  ports:
  - name: http
    number: 80
    protocol: http

  ports:
  - name: grpc
    number: 3000
    protocol: grpc

  ports:
  - name: ssh
    number: 22
    protocol: tcp

  ports:
  - name: postgres
    number: 5432
    protocol: tcp

Step 5: Resource Allocation​

Set resource limits for your application within the environment:

CPU Allocation​

  • Unit: Cores or millicores
  • Examples:
    • 0.5 cores (500 millicores)
    • 1 core
    • 2 cores

Guidelines:

  • Small apps/APIs: 0.5 - 1 core
  • Medium apps: 1 - 2 cores
  • Large apps: 2+ cores

Memory Allocation​

  • Unit: MB or GB
  • Examples:
    • 512 MB
    • 1024 MB (1 GB)
    • 2048 MB (2 GB)

Guidelines:

  • Small apps: 256 - 512 MB
  • Medium apps: 512 MB - 2 GB
  • Large apps: 2 GB+

Step 6: Environment Variables (Optional)​

Add environment variables your application needs:

Option 1: Direct Entry​

Add variables individually:

Key: DATABASE_URL
Value: postgresql://user:pass@host:5432/db

Key: NODE_ENV
Value: production

Key: PORT
Value: 3000

Option 2: Variable Sets​

Use pre-configured variable sets (recommended):

  1. Click "Attach Variable Set"
  2. Select an existing variable set
  3. All variables from the set are applied

See Variable Sets for more information.

Best Practices​

  • Use variable sets for shared configuration
  • Never commit secrets to version control
  • Use different variables for different environments
  • Document what each variable does

Step 7: Volumes (Optional)​

Attach persistent storage to your application:

Creating a New Volume​

  1. Click "Add Volume"
  2. Configure volume settings:
    • Name: Unique identifier
    • Size: Storage capacity (GB)
    • Mount Path: Path inside container (e.g., /data)

Attaching Existing Volume​

  1. Click "Attach Existing Volume"
  2. Select from available volumes
  3. Specify mount path

Common Mount Paths:

Database data: /var/lib/postgresql/data
Application data: /app/data
Uploads: /app/uploads
Logs: /var/log/app

See Volumes for detailed information.

Step 8: Review and Deploy​

  1. Review all configuration settings
  2. Verify container image name and tag
  3. Check resource allocations
  4. Click "Deploy Application"

Your application will now be deployed to the environment!

After Deployment​

Once your application is deployed:

  1. Monitor Status: Check the application dashboard
  2. View Logs: Access real-time application logs
  3. Check Health: Verify the application is running correctly
  4. Update Configuration: Modify settings as needed

Common Application Examples​

Web Applications and APIs​

Typical Configuration:

- name: webapp
  image: nginx
  tag: latest
  resources:
  - cpu: 100m
    memory: 350MB
    storage: 500MB
  ports:
  - name: http
    number: 3000
    protocol: http
    expose: true

Databases​

Typical Configuration:

- name: database
  image: postgres
  tag: alpine
  resources:
  - cpu: 100m
    memory: 128MB
    storage: 500MB
  ports:
  - name: tcp
    number: 5432
    protocol: tcp
  volumes:
  - storage: 1GB
    path: /var/lib/postgresql/data
  varsets:
  - POSTGRES_USER: gitea
    POSTGRES_PASSWORD: gitea
    POSTGRES_DB: gitea

Workers Services​

Typical Configuration:

- name: worker
  image: airbyte
  tag: worker
  resources:
  - cpu: 100m
    memory: 350MB
    storage: 500MB

Common Issues​

Image Validation Errors​

Problem: "Container image not found or not accessible. Please verify the image exists in registry."

Solutions:

  • Verify the image name and tag are correct
  • Ensure the image exists
  • Try pulling the image locally with docker pull image:tag

Application Won't Start​

Problem: Application shows as failed or crashing

Solutions:

  • Check application logs for error messages
  • Verify environment variables are set correctly
  • Ensure port configuration matches application
  • Check resource allocation is sufficient

Best Practices​

Image Selection​

  • ✅ Use official images when possible (nginx, postgres, redis)
  • ✅ Specify exact version tags for production (postgres:14 not postgres:latest)
  • ✅ Use Alpine variants for smaller image sizes (node:18-alpine)
  • ✅ Test images in development before deploying to production

Resource Planning​

  • Start with minimal resources and scale up as needed
  • Over-provision slightly for production workloads
  • Use appropriate resources for the application type

Environment Variables​

  • Store sensitive data in variable sets
  • Use different variable sets per environment
  • Document all required variables
  • Never hardcode secrets in images

Next Steps​