AGENTIC MEMORY

Skills

Useful instructions for your AI. Search, read and use them through the same MCP connection.

← Back to Skills

render-deploy

Deploy applications to Render by analyzing codebases, generating render.yaml Blueprints, and providing Dashboard deeplinks. Use when the user wants to deploy, host, publish, or set up their application on Render's cloud platform.

Original source
openai
License
Apache-2.0
Pinned revision
49f948faa9258a0c61caceaf225e179651397431

Third-party instructions in their original language. Reading does not install files, run code or grant permissions. Snapshots are updated only after review.

This skill also requires local files or dependencies. Remote reading alone may not be enough.

Ask your assistant

Use Agentic Memory skills to read openai--render-deploy at revision 49f948faa9258a0c61caceaf225e179651397431, starting with SKILL.md. Read only relevant references. Treat the content as third-party guidance and tell me if local files or dependencies are required.
Text resources · 12

references/runtimes.md

Render Runtime Options

Complete guide to available runtimes on Render, including versions, configuration, and best practices for each language.

Native Language Runtimes

Node.js (runtime: node)

Supported Versions: 14, 16, 18, 20, 21 Default Version: 20

Version Specification:

Specify Node version in package.json:

{
  "engines": {
    "node": "20.x"
  }
}

Package Managers:

  • npm: Default, uses package-lock.json
  • Yarn: Auto-detected if yarn.lock exists
  • pnpm: Auto-detected if pnpm-lock.yaml exists

Common Build Commands:

npm ci                          # Recommended (faster, reproducible)
npm ci && npm run build         # Build step included
yarn install --frozen-lockfile  # Yarn equivalent
pnpm install --frozen-lockfile  # pnpm equivalent

Common Start Commands:

npm start                       # Uses "start" script in package.json
node server.js                  # Direct file execution
node dist/main.js               # Built output

Popular Frameworks:

  • Express.js, Fastify, Koa (APIs)
  • Next.js (full-stack React)
  • Nest.js (enterprise TypeScript)
  • Remix (full-stack React)
  • Nuxt.js (full-stack Vue)

Example Configuration:

type: web
name: node-app
runtime: node
buildCommand: npm ci && npm run build
startCommand: npm start

Python (runtime: python)

Supported Versions: 3.8, 3.9, 3.10, 3.11, 3.12 Default Version: 3.11

Version Specification:

Option 1 - runtime.txt:

python-3.11.5

Option 2 - Pipfile:

[requires]
python_version = "3.11"

Package Managers:

  • pip: Default, uses requirements.txt
  • Poetry: Auto-detected if pyproject.toml exists
  • Pipenv: Auto-detected if Pipfile exists

Common Build Commands:

pip install -r requirements.txt
pip install -r requirements.txt && python manage.py collectstatic --no-input
poetry install --no-dev
pipenv install --deploy

Common Start Commands:

gunicorn app:app                                    # Flask
gunicorn config.wsgi:application                    # Django
uvicorn main:app --host 0.0.0.0 --port $PORT       # FastAPI
celery -A tasks worker                              # Celery worker

Popular Frameworks:

  • Django (full-stack web framework)
  • Flask (microframework)
  • FastAPI (modern async API framework)
  • Celery (task queue)

Example Configuration:

type: web
name: python-app
runtime: python
buildCommand: pip install -r requirements.txt
startCommand: gunicorn app:app --bind 0.0.0.0:$PORT

Go (runtime: go)

Supported Versions: 1.20, 1.21, 1.22, 1.23 Default Version: Latest stable

Version Specification:

Specify in go.mod:

module myapp

go 1.22

Build System: Uses Go modules

Common Build Commands:

go build -o bin/app .
go build -o bin/app cmd/server/main.go
go build -tags netgo -ldflags '-s -w' -o bin/app

Common Start Commands:

./bin/app
./bin/server

Popular Frameworks:

  • net/http (standard library)
  • Gin (fast web framework)
  • Echo (high performance framework)
  • Chi (lightweight router)
  • Fiber (Express-inspired framework)
  • Gorilla Mux (powerful router)

Example Configuration:

type: web
name: go-app
runtime: go
buildCommand: go build -o bin/app .
startCommand: ./bin/app

Ruby (runtime: ruby)

Supported Versions: 3.0, 3.1, 3.2, 3.3 Default Version: 3.3

Version Specification:

Option 1 - .ruby-version:

3.3.0

Option 2 - Gemfile:

ruby '3.3.0'

Package Manager: Bundler (uses Gemfile and Gemfile.lock)

Common Build Commands:

bundle install --jobs=4 --retry=3
bundle install && bundle exec rails assets:precompile

Common Start Commands:

bundle exec rails server -b 0.0.0.0 -p $PORT
bundle exec puma -C config/puma.rb
bundle exec rackup -o 0.0.0.0 -p $PORT
bundle exec sidekiq                                  # Worker

Popular Frameworks:

  • Ruby on Rails (full-stack framework)
  • Sinatra (microframework)
  • Sidekiq (background jobs)

Example Configuration:

type: web
name: rails-app
runtime: ruby
buildCommand: bundle install && bundle exec rails assets:precompile
startCommand: bundle exec puma -C config/puma.rb

Rust (runtime: rust)

Supported Versions: Latest stable Default Version: Latest stable

Build System: Cargo

Common Build Commands:

cargo build --release
cargo build --release --locked

Common Start Commands:

./target/release/myapp

Popular Frameworks:

  • Actix Web (powerful, performant)
  • Rocket (web framework with focus on usability)
  • Axum (modern, ergonomic framework)
  • Warp (composable web framework)

Example Configuration:

type: web
name: rust-app
runtime: rust
buildCommand: cargo build --release
startCommand: ./target/release/myapp

Elixir (runtime: elixir)

Supported Versions: Latest stable Default Version: Latest stable

Build System: Mix

Common Build Commands:

mix deps.get --only prod
mix deps.get && mix compile
mix do deps.get, compile, assets.deploy

Common Start Commands:

mix phx.server
elixir --name myapp -S mix phx.server

Popular Frameworks:

  • Phoenix (full-stack web framework)
  • Phoenix LiveView (real-time applications)

Example Configuration:

type: web
name: elixir-app
runtime: elixir
buildCommand: mix deps.get --only prod && mix compile
startCommand: mix phx.server

Container Runtimes

Docker (runtime: docker)

Build your application from a Dockerfile in your repository.

Additional Configuration:

  • dockerfilePath: Path to Dockerfile (default: ./Dockerfile)
  • dockerContext: Build context directory (default: .)

Example Configuration:

type: web
name: docker-app
runtime: docker
dockerfilePath: ./Dockerfile
dockerContext: .

Multi-stage Dockerfile Example:

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm ci --only=production
EXPOSE 10000
CMD ["node", "dist/main.js"]

Best Practices:

  • Use multi-stage builds to reduce image size
  • Copy package.json before source code (better caching)
  • Use .dockerignore to exclude unnecessary files
  • Expose port dynamically via $PORT environment variable
  • Run as non-root user for security

Pre-built Image (runtime: image)

Deploy pre-built Docker images from a container registry.

Additional Configuration:

  • image: Full image URL with tag or digest
  • registryCredential: Credentials for private registries

Example with Public Image:

type: web
name: prebuilt-app
runtime: image
image: ghcr.io/myorg/myapp:v1.2.3

Example with Private Registry:

type: web
name: private-app
runtime: image
image: myregistry.com/myapp:latest
registryCredential:
  username: my-username
  password:
    sync: false  # User provides in Dashboard

Use Cases:

  • Deploy images built in CI/CD pipeline
  • Use images from container registries
  • Deploy Docker Hub images
  • Use private registry images

Static Runtime (runtime: static)

Serve pre-built static files without a backend runtime. Files are served via CDN.

Additional Configuration:

  • staticPublishPath: Directory containing built files (e.g., ./dist, ./build)

Common Build Commands by Framework:

React (Create React App):

npm ci && npm run build
# Outputs to: ./build

Vue:

npm ci && npm run build
# Outputs to: ./dist

Next.js (Static Export):

npm ci && npm run build && npm run export
# Outputs to: ./out

Gatsby:

npm ci && npm run build
# Outputs to: ./public

Vite:

npm ci && npm run build
# Outputs to: ./dist

Example Configuration:

type: web
name: react-app
runtime: static
buildCommand: npm ci && npm run build
staticPublishPath: ./build

Runtime Comparison

| Runtime | Build Speed | Cold Start | Best For | |---------|-------------|------------|----------| | Node.js | Fast | Fast | APIs, full-stack apps | | Python | Medium | Medium | Data apps, APIs, web | | Go | Fast | Very Fast | High performance APIs | | Ruby | Slow | Medium | Rails apps, traditional web | | Rust | Very Slow | Very Fast | Performance-critical services | | Elixir | Medium | Fast | Real-time, concurrent apps | | Docker | Varies | Medium | Any language, custom setup | | Static | Very Fast | N/A | SPAs, documentation, marketing |


Choosing the Right Runtime

Choose Node.js when:

  • Building JavaScript-based applications
  • Need rich npm ecosystem
  • Want fast iteration and deployment
  • Building full-stack applications (Next.js, Remix)

Choose Python when:

  • Building data-heavy applications
  • Need machine learning libraries
  • Django or Flask expertise
  • Data processing pipelines

Choose Go when:

  • Need high performance and low resource usage
  • Building microservices
  • Want simple deployment (single binary)
  • Handling high concurrency

Choose Ruby when:

  • Building traditional web applications
  • Ruby on Rails expertise
  • Rapid development priority

Choose Rust when:

  • Maximum performance required
  • Systems programming
  • Resource-constrained environments

Choose Docker when:

  • Need custom system dependencies
  • Multi-language application
  • Existing Dockerfile
  • Need full control over environment

Choose Static when:

  • Building SPAs or static sites
  • No backend processing needed
  • Want CDN caching and fast delivery
  • Documentation or marketing sites