LogoLogo
  • Welcome to Release
  • Getting started
    • Quickstart
    • Create an account
    • Prepare to use Release
    • Create an application
      • Create custom application
      • Create from template
      • Servers vs runnables
    • Create an environment
  • Guides and examples
    • Domains and DNS
      • Manage domains
      • DNS and nameservers
        • Configure GoDaddy
        • Configure Cloudflare
        • Configure Namecheap
        • Other DNS hosts
      • Routing traffic
    • Example applications
      • Full stack voting app
      • Flask and RDS counter app
      • Static site with Gatsby
      • Golang with Postgres and Nginx
      • WordPress with MySQL
      • Spring and PostgreSQL
      • Terraform and Flask
      • OpenTelemetry demo
      • Load balancer with hostname
      • Static JavaScript service
      • SSH bastion access to services
      • ngrok and OAuth for private tunnels
      • Using OAuth Proxy
      • Hybrid Docker and static site
      • App Imports: Connecting two applications
      • Example library
    • Running instances
      • Cron jobs
      • Jobs
      • Using Helm charts
      • Using terminal
      • Viewing logs
      • Troubleshooting
        • ImagePullBackoff error
        • CrashLoopBackoff error
        • Exit codes
        • OOM: out of memory
    • Advanced guides
      • Containers guide
      • Application guide
      • Kubernetes guide
      • Create a cluster
      • Upgrade a cluster
      • Managing node groups
      • Patch node groups
      • Hostnames and rules
      • Serve traffic on multiple ports
      • Configure access to your K8s cluster
      • Designing for multiple environments
      • Microservices architecture
      • Monitoring your clusters
      • Performance tuning
      • Visibility and monitoring
      • Working with data
        • Container-based data
        • Seeding and migration
        • Cloud-provided data
        • Golden images
        • Third party
      • Pausing Instant Datasets
        • Application pausing schedules
        • Pause/resume environments
      • Infrastructure as code
        • Terraform
  • Reference documentation
    • Account settings
      • Account info
      • Managing users
      • Build settings
        • Build arguments
        • Build SSH keys
      • Add integrations
      • View clusters and cloud integrations
      • Add datasets
      • Environment handles
    • Workflows in Release
      • Stages of workflows
      • Serial deployments
      • Parallel deployments
      • Rolling deployments
      • Rainbow deployments
    • Networking
      • Network architecture (AWS)
      • Network architecture (GCP)
      • Ingresses
      • IP addresses
      • Cloud-provided services
      • Third-party services
    • Release environment versioning
    • Application settings
      • Application Template
        • Schema definition
      • Default environment variables
      • GitHub
      • Pull requests
      • GitOps
      • Just-in-time file mounts
      • Primary App Link
      • Create application FAQ
      • App-level build arguments
      • Parameters
      • Workspaces
    • End-to-end testing
    • Environment settings
      • Environment configuration
      • Environment variables
        • Environment variable mappings
        • Secrets vaults
        • Using Secrets with GitOps
        • Kubernetes Secrets as environment variables
        • Managing legacy Release Secrets
    • Environment expiration
    • Environment presets
    • Instant datasets on AWS
    • Instant datasets on GCP
    • Instant dataset tasks
      • Tonic Cloud
      • Tonic On-Premise
    • Cloud resources
    • Static service deployment
    • Helm
      • Getting started
      • Version-controlled Helm charts
      • Open-source charts
      • Building Docker images
      • Ingress and networking
      • Configuration
    • GitOps
    • The .release.yaml file
    • Docker Compose conversion support
    • Reference examples
      • Adding and removing services
      • Managing service resources
      • Adding database containers to the Application Template
      • Stock Off-The-Shelf Examples
    • Release API
      • Account Authentication
      • Environments API
        • Create
        • Get
        • Setup
        • Patch
      • User Authentication
      • Environment Presets API
        • Get Environment Preset List
        • Get Environment Preset
        • Put Environment Preset
  • Background concepts
    • How Release works
  • Frequently asked questions
    • Release FAQ
    • AWS FAQ
    • Docker FAQ
    • JavaScript FAQ
  • Integrations
    • Integrations overview
      • Artifactory integration
      • Cloud integrations (AWS)
        • AWS guides
        • Grant access to AWS resources
        • AWS how to increase EIP quota
        • Control your EKS fleet with systems manager
        • Managing STS access
        • AWS Permissions Boundaries
        • Private ECR Repositories
        • Using an Existing AWS VPC
        • Using an Existing EKS Cluster
      • Docker Hub integration
      • LaunchDarkly integration
      • Private registries
      • Slack integration
      • Cloud integrations (GCP)
        • GCP Permissions Boundary
      • Datadog Agent
      • Doppler Secrets Manager
      • AWS Secrets Management
    • Source control integrations
      • GitHub
        • Pull request comments
        • Pull request labels
        • GitHub deployments
        • GitHub statuses
        • Remove GitHub integration
      • Bitbucket
      • GitLab
    • Monitoring and logging add-ons
      • Datadog
      • New Relic
      • ELK (Elasticsearch, Logstash, and Kibana)
  • Release Delivery
    • Create new customer integration
    • Delivery guide
    • Release to customer account access controls
    • Delivery FAQs
  • Release Instant Datasets
    • Introduction
    • Quickstart
    • Security
      • AWS Instant Dataset security
    • FAQ
    • API
  • CLI
    • Getting started
    • Installation
    • Configuration
    • CLI usage example
    • Remote development environments
    • Command reference
      • release accounts
        • release accounts list
        • release accounts select
      • release ai
        • release ai chat
        • release ai config-delete
        • release ai config-init
        • release ai config-select
        • release ai config-upsert
      • release apps
        • release apps list
        • release apps select
      • release auth
        • release auth login
        • release auth logout
      • release builds
        • release builds create
      • release clusters
        • release clusters exec
        • release clusters kubeconfig
        • release clusters shell
      • release datasets
        • release datasets list
        • release datasets refresh
      • release deploys
        • release deploys create
        • release deploys list
      • release development
        • release development logs
        • release development start
      • release environments
        • release environments config-get
        • release environments config-set
        • release environments create
        • release environments delete
        • release environments get
        • release environments list
        • release environments vars-get
      • release gitops
        • release gitops init
        • release gitops validate
      • release instances
        • release instances exec
        • release instances logs
        • release instances terminal
  • Release.ai
    • Release.ai Introduction
    • Getting Started
    • Release.ai Templates
    • Template Configuration Basics
    • Using GPU Resources
    • Custom Workflows
    • Fine Tuning LlamaX
    • Serving Inference
Powered by GitBook
On this page
  • Step 1: Create an application
  • Step 2: Analyze the repository
  • Step 3: Generate a template
  • Step 4: Set environment variables
  • Step 5: Set build arguments
  • Step 6: Save and deploy
  • Create an environment
  • What's next? Push an update to your repository to see how Release builds and redeploys your application
  • Learn by doing: Example applications

Was this helpful?

  1. Getting started
  2. Create an application

Create custom application

Learn how to create a custom application in Release

PreviousCreate an applicationNextCreate from template

Last updated 11 months ago

Was this helpful?

This guide provides step-by-step instructions for creating a custom application in Release.

Step 1: Create an application

Log in to your Release account and navigate to Applications. Click Create Application and select Create Custom from the dropdown to start the setup process.

Provide a name for your application. This name will be used in hostnames and for identification purposes in Release.

Next, select the repository and branch that contains your application code. Release will use this repository to analyze and create the initial setup for the application. It’s important to pick the correct branch that holds the latest version of your code.

Step 2: Analyze the repository

Release can analyze your repository to detect services based on Docker Compose files, or package.json for static/node services, or a .release.yaml file for an existing Application Template.

Select the branch of the repository and the specific files you want Release to analyze. For example, you might choose the master branch and select files like Dockerfile and docker-compose.yml. These files provide Release with information about your application’s services and dependencies.

Click Start Analysis to have Release scan your repository.

Release will now read the files you selected and create a list of services found. Each service has a checkbox, a list of dependencies, and a service type.

  1. Select or deselect a service by clicking the checkbox next to the service's name.

  2. Select the service type. Release tries to automatically select the correct service type for each service. This field will only be editable when the service type is ambiguous.

  3. Under the dependsOn field, you'll see a list of services that a given service depends on. Release tries to deploy services in parallel to save time, but if a service depends on other services, dependencies will be deployed before this service is deployed.

  4. Once you've selected your services, click Next step.

Step 3: Generate a template

Alternatively, you can create a custom template from scratch, or use one of Release’s preset templates. For instance, if you’re working with a Node.js application, choose the Node.js preset template.

Customize the default settings for resources such as CPU, memory, and replicas based on the application's requirements to ensure it runs efficiently. For example, you might allocate 1000m CPU and 1Gi of memory.

You can also define any workflows needed for your application here. Workflows may include setup tasks, deployment processes, or other automation steps.

If you're done editing your Application Template, click the Next step button.

Step 4: Set environment variables

Environment variables provide information the application needs, like database connection strings, API keys, and other configuration settings.

Release will try to import your default environment variables from your Docker Compose file (if selected previously), and interpolate values from a .env file (if present in your repository).

For example, you might add the following environment variables:

  • DB_HOST: mysql.example.com

  • DB_USER: root

  • DB_PASS: password123

Edit the environment variables specification and click Next step to proceed.

Step 5: Set build arguments

Build arguments are passed to the Release build process. Typically, these would be arguments used in the Docker build process.

To add a new build argument:

  • Click on Add build arg.

  • Enter a Key.

  • Enter a Value.

Repeat these steps for all build arguments you need to add, then click Next Step.

Step 6: Save and deploy

Now you can save and deploy the application.

You have the opportunity to go back to any of the preceding steps to edit your application.

You can return to any of the preceding steps to edit the application. When you're ready, click on the Finish Setup button.

Release will now save your new application template.

Create an environment

You can now create an environment for your application. Click on the Create Environment button to create an environment for your application.

From the environment detail page, you can click on the hosted URLs for this environment to use your application.

What's next? Push an update to your repository to see how Release builds and redeploys your application

If you push updates to your repository, Release will pull your new code, build your application, and redeploy your environment.

Learn by doing: Example applications

Select the execution type for the application. If the application needs to run continuously, choose Server. If it only runs on demand, completing tasks as required, select Runnable. .

After analyzing your repository, you’ll need to generate an template. Release will automatically create a template based on the services and dependencies identified in your repository. You can customize this template to match your application’s requirements.

Learn more about in Release.

Go to the guide to learn more on how to create an environment for your application.

You can follow along with one of our many or spin up one of the boilerplate apps found in our .

Note: Release creates an initial ephemeral environment from the Create Application process. After your application is created, you can manually (including permanent environments) from the Environments page.

Learn more about servers and runnables
Application
environment variables
Create an Environment
example apps
example library
create new environments
The create new custom app button in Release
Select a repo
Server or runnable
Choose the files for Release to analyze
You can now select the services needed and see their dependencies
Generate template
Configure the environment variables for the application
Add Build Args
Save App template
Create an enviroment