Skip to main content

How to Deploy an Application

This guide walks through the complete process of deploying a containerized application to the Strongly platform.

Prerequisites​

Before deploying, ensure you have:

  • Your application code in a directory
  • A Dockerfile in the project root
  • A strongly.manifest.yaml configuration file
  • Optional: .env file for environment variables

Step 1: Navigate to Apps​

  1. Click Apps in the main navigation
  2. Click Deploy App button

Step 2: Configure Your App​

Basic Information​

Provide essential metadata about your application:

  • App Name: Unique identifier (lowercase, alphanumeric, hyphens only)
  • Description: Brief description of your app
  • Environment: Select an environment (uses custom environmentId for compute resource provisioning)
Naming Rules

App names must be lowercase and can only contain alphanumeric characters and hyphens. No spaces or special characters.

Upload Code​

Upload your application code as a compressed archive, connect a GitHub repository, or use a project bundle:

Archive upload:

  • Accepted formats: .zip, .tar, .tar.gz, .tgz
  • Required files:
    • Dockerfile (in project root)
    • strongly.manifest.yaml (in project root)
  • Optional: .env file for environment variables

Other sources:

  • GitHub: Connect a GitHub repository directly
  • Project bundle: Deploy from platform project bundles
Archive Structure

Ensure your Dockerfile and manifest are in the root of the archive, not in a subdirectory.

Resource Configuration​

Select a resource tier or configure custom resources:

TierCPUMemoryDiskUse Case
Small0.5512MB5GBDevelopment, testing
Medium11GB10GBSmall production apps
Large22GB20GBProduction apps with moderate traffic
XLarge44GB40GBHigh-traffic production apps
Custom---Specialized requirements (including GPU)

Instances: Set the number of replicas (1-10) for high availability. Each instance runs on its own pod.

GPU support: For compute-intensive workloads, configure GPU resources in the manifest's resources section with the gpu field.

Step 3: Connect Services (Optional)​

Connect your app to platform services - all connections are automatically injected via the STRONGLY_SERVICES environment variable.

Add-ons (Managed Databases)​

  1. Click Add-ons button during app configuration
  2. Select from available MongoDB, Redis, PostgreSQL, and other instances
  3. Connection strings automatically injected

Data Sources (External Databases)​

  1. Connect to external MySQL, PostgreSQL, S3, Snowflake, etc.
  2. Credentials encrypted and injected at runtime

AI Models (AI Gateway)​

  1. Select from available OpenAI, Anthropic, or self-hosted models
  2. API endpoints and configuration automatically provided
  3. Usage tracked through platform

ML Models (Model Registry)​

  1. Connect traditional or AutoML models from the model registry
  2. Inference endpoints automatically configured

Workflows (REST API Triggers)​

  1. Connect workflows with REST API trigger nodes
  2. Invoke workflows from your app code
  3. Automatic authentication and execution tracking

MCP Servers​

  1. Connect MCP (Model Context Protocol) servers
  2. Access tools, prompts, and resources from your application

Step 4: Deploy & Monitor​

  1. Review Configuration: Check all settings before deployment
  2. Click Deploy: Initiate build and deployment process
  3. Monitor Build: Watch build progress via SSE streaming (timeout: 20 minutes)
  4. Access App: Once deployed, click "View App" or navigate to /apps/your-app-id/view

Build Process​

The platform automatically:

  1. Extracts your code archive (or clones from GitHub)
  2. Builds Docker image using your Dockerfile (via Kaniko in Kubernetes)
  3. Pushes image to ECR (container registry)
  4. Creates Kubernetes Deployment, Service, and PodDisruptionBudget
  5. Injects environment variables and service connections (including STRONGLY_SERVICES)
  6. Starts health checks

Build progress is streamed in real-time via Server-Sent Events (SSE).

Build Timeout

Builds must complete within 20 minutes. Optimize your Dockerfile with multi-stage builds and layer caching to reduce build time.

Build Status Flow​

Builds progress through the following statuses:

pending -> building -> completed
                    -> failed
                    -> cancelled
                    -> timeout

App Management​

Start/Stop/Restart​

Use the available actions to manage your application lifecycle:

  • apps.startApp: Start a stopped application
  • apps.stopApp: Stop a running application
  • apps.restartApp: Restart an application (stop then start)
  • apps.deploy: Deploy or redeploy an application

Update Configuration​

Update your running application:

  • Update environment variables
  • Scale instances up or down
  • Add or remove connected services
  • Redeploy to apply changes
Redeploy Required

Configuration changes require redeployment. The existing deployment is deleted first and a new one is created.

View Logs & Metrics​

Monitor your application in real-time:

  • Real-time log streaming
  • CPU and memory usage percentages
  • Ready and total replica counts
  • Health check status

Common Deployment Issues​

Build Fails​

  • Check Dockerfile syntax
  • Ensure all dependencies are accessible
  • Verify build context includes all required files
  • Check build logs for specific errors

App Builder Unreachable​

If you see an app-builder-unreachable error:

  • The app builder backend service is not responding
  • Check that the app builder service is running
  • Verify network connectivity between frontend and backend

App Won't Start​

  • Verify health check endpoint is accessible
  • Check application logs for startup errors
  • Ensure environment variables are set correctly
  • Verify port configuration matches manifest

Connection Issues​

  • Check STRONGLY_SERVICES environment variable is properly parsed
  • Verify credentials and connection strings
  • Test connectivity from app terminal

Next Steps​