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: Choose your execution type
  • Step 3: Select a template
  • Step 4: Configure your application
  • Step 5: Finish and create environment

Was this helpful?

  1. Getting started
  2. Create an application

Create from template

Learn how to create applications from templates in Release

PreviousCreate custom applicationNextServers vs runnables

Last updated 11 months ago

Was this helpful?

Release simplifies the process of creating and deploying applications by using preset templates. These templates are pre-configured environments tailored to specific use cases, allowing you to get your applications up and running quickly without needing to handle the intricate details of setup and configuration.

Release templates are designed to handle the configurations required for various environments and optimized for specific tasks like running Jupyter Notebooks, deploying language models, or fine-tuning machine learning models. This guide provides step-by-step instructions for creating an application from a template in Release.

Step 1: Create an application

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

Step 2: Choose your execution type

Release offers two types of templates: Server and Runnable. The type you choose depends on the nature of your application.

Step 3: Select a template

The stack icons in the top-right corner of each template card represent the core technologies and integrations included in the template.

Server Templates:

  • Jupyter: For GPU-accelerated Jupyter Notebooks.

  • Ollama: For large language models.

  • Ollama-WebUI: A feature-rich, self-hosted WebUI.

  • GenAI: For building GenAI applications.

  • Anything-LLM: Other language model-based applications.

Alternatively, you can choose a runnable template for your application by selecting the Runnable tickbox.

Runnable Templates:

  • NeMo: For fine-tuning models with NeMo.

  • Pytorch: A container with PyTorch and NVIDIA GPU drivers.

  • Axolotl: Another option for fine-tuning models.

Step 4: Configure your application

Release will automatically generate a name for your application based on the template you choose. You can change this name to something more descriptive if you wish.

Edit the template configuration settings to suit your specific requirements. These settings include the application’s name, a description, and the resources allocated to it. You can also choose the environment in which the application will run, such as a CPU or GPU environment.

Step 5: Finish and create environment

Once you have configured your application, click Finish to save your app template. You can now create an environment for your application by going to the application’s page and clicking Create Environment.

Server: Server templates are meant for applications that need a persistent server environment. For instance, running a Jupyter Notebook server with GPU acceleration requires a stable, long-running server. Learn more about .

Runnable: Runnable templates are for applications that can be executed on demand. This is ideal for tasks like fine-tuning models, where the application does not need to run continuously. Learn more about .

Choose the template that best suits your application requirements. Release offers a range of templates optimized for specific tasks. To learn more about the available templates, check out the .

To learn more about runnables, check out the .

To learn more about configuring your application, check out the .

Learn more about in Release.

server applications
runnable applications
template library
runnable documentation
configuration documentation for templates
creating environments
Create App
Select Server or Runnable
Select a server template
Select a Runnable Template
Configure your Application Template