Miren

https://miren.md/
Admin
Miren is a container platform for small teams that automates application deployment, builds,...
Tokens:232,455
Snippets:2,709
Trust Score:4.2
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start the runner example

Source: https://miren.md/command/runner-start

Starts the runner with default settings.

```bash
miren runner start
```

--------------------------------

### Procfile examples for Node.js and Bun start commands

Source: https://miren.md/guides/javascript

Define explicit start commands for Node.js and Bun apps. Miren runs the package.json start script by default, but a Procfile makes the command explicit. Includes examples for direct scripts, compiled output, Next.js, Elysia, and background workers.

```Procfile
# Node — direct  
web: node server.js  
  
# Node — npm script  
web: npm start  
  
# Node — yarn script  
web: yarn start  
  
# Express — compiled output  
web: node dist/index.js  
  
# Next.js  
web: npm run start  
  
# Bun — run TypeScript directly  
web: bun run src/index.ts  
  
# Bun — run JavaScript  
web: bun run src/index.js  
  
# Bun — package.json script  
web: bun run start  
  
# Bun — Elysia  
web: bun run src/server.ts  
  
# Background worker (Node)  
worker: node worker.js  
  
# Background worker (Bun)  
worker: bun run worker.ts  
```

--------------------------------

### Cold-start trace example

Source: https://miren.md/observability

Example trace output showing a cold-start request. The `httpingress` span covers the full request lifecycle, `httpingress.lease` shows lease acquisition (cold start), and containerd spans show image pull and task creation. The proxy-to-app span and your app's span appear as children.

```text
httpingress                          [350ms]
├─ httpingress.lease                 [200ms]  (cold start)
│  ├─ rpc.call.AcquireLease         [195ms]
│  │  ├─ containerd...Images/Pull   [150ms]
│  │  └─ containerd...Tasks/Create  [40ms]
├─ [proxy to app]                   [150ms]
│  └─ my-app: GET /api/users        [145ms]  (your app's span)

```

--------------------------------

### Bun + PostgreSQL example: app.toml, index.ts, and deploy

Source: https://miren.md/addons

Deploys a Bun + PostgreSQL app. The app.toml declares the service and addon, index.ts uses the injected DATABASE_URL to create a table and track visits, and miren deploy provisions the addon and starts the app.

```toml
name = "my-bun-app"

[services.web]
command = "bun run index.ts"

[addons.miren-postgresql]
variant = "shared"
```

```typescript

const sql = new SQL({ url: process.env.DATABASE_URL });

await sql`
  CREATE TABLE IF NOT EXISTS visits (
    id SERIAL PRIMARY KEY,
    visited_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
  )
`;

const server = Bun.serve({
  port: process.env.PORT || 3000,
  async fetch(req) {
    await sql`INSERT INTO visits DEFAULT VALUES`;
    const [{ count }] = await sql`SELECT COUNT(*) as count FROM visits`;
    return new Response(`Visits: ${count}\n`);
  },
});
```

```miren
miren deploy
```

--------------------------------

### Complete app.toml example

Source: https://miren.md/app-configuration

Complete app.toml configuration for a Miren application. Defines environment variables, build version, web and worker services, and a Postgres service with a persistent disk. Use as a starting point for a full deployment configuration.

```toml
name = "myapp"

[[env]]
key = "DATABASE_URL"
value = "postgres://user:pass@postgres.app.miren:5432/myapp"

[[env]]
key = "SECRET_KEY"
required = true
sensitive = true
description = "Application secret for session signing"

[build]
version = "3.12"

[services.web]
command = "gunicorn app:app --bind 0.0.0.0:8000"
port = 8000

[services.web.concurrency]
mode = "auto"
requests_per_instance = 20

[services.worker]
command = "celery -A app worker"

[services.worker.concurrency]
mode = "fixed"
num_instances = 2

[services.postgres]
image = "postgres:16"

[[services.postgres.env]]
key = "PGDATA"
value = "/var/lib/postgresql/data/pgdata"

[services.postgres.concurrency]
mode = "fixed"
num_instances = 1

[[services.postgres.disks]]
name = "myapp-pgdata"
mount_path = "/var/lib/postgresql/data"
size_gb = 20
```

--------------------------------

### Install Miren Server

Source: https://miren.md/getting-started

Run as server or with sudo to install the Miren runtime. Registers with miren.cloud and starts the systemd service.

```miren
sudo miren server install
```

--------------------------------

### Install with token for automation

Source: https://miren.md/command/runner-install

Uses the `--token` flag to provide an enrollment token, enabling non-interactive installation for automation.

```bash
miren runner install --token mren_...
```

--------------------------------

### Install interactively

Source: https://miren.md/command/runner-install

Runs the installer without flags, prompting for required information interactively.

```bash
miren runner install
```

--------------------------------

### Dockerfile.miren: install Quicklisp and preload Hunchentoot

Source: https://miren.md/guides/commonlisp

Dockerfile.miren that uses clfoundation/sbcl:latest, installs curl, installs Quicklisp, preloads Hunchentoot during build, copies the app, exposes port 8080, and runs app.lisp with sbcl.

```dockerfile
FROM clfoundation/sbcl:latest  
  
RUN apt-get update -y && apt-get install -y curl && rm -rf /var/lib/apt/lists/* \  
    && curl -sO https://beta.quicklisp.org/quicklisp.lisp \  
    && sbcl --non-interactive --load quicklisp.lisp \  
        --eval '(quicklisp-quickstart:install :path "/quicklisp")' \  
    && sbcl --non-interactive --load /quicklisp/setup.lisp \  
        --eval '(ql:quickload :hunchentoot)'  
  
WORKDIR /app  
COPY . /app  
EXPOSE 8080  
CMD ["sbcl", "--disable-debugger", "--load", "/app/app.lisp"]  

```

--------------------------------

### Dockerfile.miren for OCaml/Dream build

Source: https://miren.md/guides/ocaml

Multi-stage Dockerfile for building an OCaml/Dream app. Uses USER root to install system packages because sudo fails in Miren's sandbox, then switches back to USER opam and passes --no-depexts to opam install. The runtime stage installs libev4, libgmp10, libssl3, and ca-certificates, copies the built binary, and sets CMD to start the app.

```dockerfile
# ----- Build stage -----  
FROM ocaml/opam:debian-12-ocaml-5.2 AS builder  
  
# Install system libraries Dream needs. Miren's build sandbox runs without  
# new privileges, so `sudo` fails here — switch to root instead.  
USER root  
RUN apt-get update -y \  
    && apt-get install -y libev-dev libgmp-dev libssl-dev pkg-config m4  
USER opam  
  
WORKDIR /app  
COPY --chown=opam:opam . .  
# System deps are already installed above, so skip opam's sudo-based depext step.  
RUN opam install -y --no-depexts dream dune  
RUN opam exec -- dune build --profile release ./main.exe  
  
# ----- Runtime stage -----  
FROM debian:12-slim  
  
RUN apt-get update -y \  
    && apt-get install -y libev4 libgmp10 libssl3 ca-certificates \  
    && apt-get clean && rm -rf /var/lib/apt/lists/*  
  
COPY --from=builder /app/_build/default/main.exe /usr/local/bin/app  
  
EXPOSE 8080  
CMD ["app"]  


```

--------------------------------

### .dockerignore example

Source: https://miren.md/guides/static

Example .dockerignore file to exclude .git, node_modules, and dist from the Docker build context.

```text
.git
node_modules
dist
```

--------------------------------

### miren app run command examples

Source: https://miren.md/command/app-run

These examples show how to use the miren app run command. The first opens an interactive shell, the second runs a specific command, the third runs database migrations, the fourth runs a declared task, and the fifth starts a task without attaching a terminal.

```bash
miren app run
```

```bash
miren app run -- bin/rails console
```

```bash
miren app run -- bin/rails db:migrate
```

```bash
miren app run --task reindex
```

```bash
miren app run --task reindex --detach
```

--------------------------------

### Generate auth config example

Source: https://miren.md/command/auth-generate

A simple example of running the miren auth generate command to create an authentication configuration file.

```bash
miren auth generate
```

--------------------------------

### Show current cluster example

Source: https://miren.md/command/cluster-current

Example command to display the currently pinned cluster.

```bash
miren cluster current
```

--------------------------------

### Example output of 'miren auth ci list'

Source: https://miren.md/ci-deploy

Example output from 'miren auth ci list -a myapp'. Shows two bindings: one for GitHub with conditions on repository, owner, and events, and one for a generic provider with a project path condition.

```text
ID         PROVIDER   ISSUER                                        SUBJECT                   CONDITIONS
abc123     github     https://token.actions.githubusercontent.com                             repository=acme/web-app; repository_owner=acme; event_name=push,workflow_dispatch
def456     generic    https://gitlab.com                            project_path:acme/web-*
```

--------------------------------

### Install required networking tools

Source: https://miren.md/system-requirements

Install the necessary iptables and nftables packages using your distribution's package manager.

```bash
# Debian/Ubuntu
sudo apt install iptables nftables

# RHEL/Fedora
sudo dnf install iptables nftables
```

--------------------------------

### Join a runner and install it as a service

Source: https://miren.md/distributed-runners

Run on the machine being added: join the cluster with the token and install the runner as a service.

```miren
miren runner join mren_...
miren runner install
```

--------------------------------

### miren server container install command syntax

Source: https://miren.md/command/server-container-install

Shows the command syntax for installing the miren server in a container. Use this to see the available flags and global options.

```bash
miren server container install [flags]
```

--------------------------------

### miren server install command syntax

Source: https://miren.md/command/server-install

Shows the base command syntax for installing the miren server as a systemd service. Use this form to see available flags and options.

```bash
miren server install [flags]
```

--------------------------------

### Get a variable value

Source: https://miren.md/command/env-get

Example command to get the value of the DATABASE_URL environment variable.

```bash
miren env get DATABASE_URL
```

--------------------------------

### Example server.toml configuration

Source: https://miren.md/server-config

A sample configuration file demonstrating settings for server address, ingress, TLS, etcd, and buildkit storage management.

```toml
mode = "standalone"

[server]
address = ":8443"
data_path = "/var/lib/miren"
http_request_timeout = 60

[ingress]
mode = "tls-autoprovision"

[tls]
acme_email = "admin@example.com"

[etcd]
start_embedded = true

[buildkit]
gc_keep_storage = "20GB"
gc_keep_duration = "14d"
```

--------------------------------

### Node.js OpenTelemetry auto-instrumentation setup

Source: https://miren.md/observability

Set up OpenTelemetry auto-instrumentation for a Node.js app. Install the auto-instrumentations package, configure the OTLP endpoint, service name, and `NODE_OPTIONS` in `.miren/app.toml`. The `--require` flag loads auto-instrumentation before app start, instrumenting HTTP, Express, and other common libraries.

```bash
npm install @opentelemetry/auto-instrumentations-node

```

```toml
[[env]]
key = "OTEL_EXPORTER_OTLP_ENDPOINT"
value = "https://your-otel-collector:4318"

[[env]]
key = "OTEL_SERVICE_NAME"
value = "my-node-app"

[[env]]
key = "NODE_OPTIONS"
value = "--require @opentelemetry/auto-instrumentations-node/register"

```

--------------------------------

### Route a domain to an app

Source: https://miren.md/command/route-set

Example that routes example.com to the myapp application.

```bash
miren route set example.com myapp
```

--------------------------------

### Dockerfile.miren for Raku with Cro

Source: https://miren.md/guides/raku

Dockerfile.miren for a Raku app. Uses rakudo-star:latest, installs libssl-dev before zef install (required for Cro::TLS), installs Cro::HTTP, and starts the app with CMD.

```dockerfile
FROM rakudo-star:latest  
RUN apt-get update -y && apt-get install -y libssl-dev && rm -rf /var/lib/apt/lists/*  
WORKDIR /app  
RUN zef install --/test Cro::HTTP  
COPY . /app  
EXPOSE 8080  
CMD ["raku", "/app/app.raku"]  

```

--------------------------------

### Example: List all pools

Source: https://miren.md/command/sandbox-pool-list

Runs the command to list all sandbox pools.

```bash
miren sandbox-pool list
```

--------------------------------

### Dockerfile.miren for Laravel/Composer with Composer install

Source: https://miren.md/guides/php

Use this Dockerfile.miren for Laravel or Composer apps. It installs Composer from a pinned image, adds PHP extensions (pdo_pgsql, pdo_mysql, zip), installs dependencies with composer install, and starts the FrankenPHP server on 0.0.0.0:$PORT.

```dockerfile
FROM dunglas/frankenphp:1-php8.3  
  
# Composer from its official pinned image — no piping a remote installer into php  
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer  
RUN install-php-extensions pdo_pgsql pdo_mysql zip  
  
WORKDIR /app  
# Copy the manifests first so the install layer is deterministic and cache-friendly;  
# committing composer.lock pins exact dependency versions.  
COPY composer.json composer.lock ./  
RUN composer install --no-dev --optimize-autoloader --no-scripts --no-interaction  
  
COPY . /app  
RUN composer dump-autoload --optimize --no-interaction  
  
EXPOSE 8080  
CMD ["sh", "-c", "exec frankenphp php-server --listen 0.0.0.0:$PORT --root /app/public"]  

```

--------------------------------

### Install miren server without cloud

Source: https://miren.md/command/server-install

Installs the miren server for local-only operation, skipping cloud registration setup. Use this when you do not want to connect to miren.cloud.

```bash
miren server install --without-cloud
```

--------------------------------

### Complete Go example using jsonrpc3 library

Source: https://miren.md/admin-interface

Complete Go example using the jsonrpc3 library to set up an admin JSON-RPC endpoint. It registers methods with introspection metadata, wraps the handler with bearer-token auth middleware, and mounts it at /.well-known/miren/admin. The code includes sample data and handler implementations for list-users, get-user, and clear-cache.

```go
package main

    "context"
    "crypto/subtle"
    "log"
    "net/http"
    "os"
    "strings"

    "miren.dev/jsonrpc3/go/jsonrpc3"
)

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    adminToken := os.Getenv("ADMIN_TOKEN")
    if adminToken == "" {
        log.Println("WARNING: ADMIN_TOKEN not set")
    }

    // Create the admin handler with method definitions
    adminMethods := jsonrpc3.NewMethodMap()

    // Register admin methods with introspection metadata
    adminMethods.Register("list-users", listUsers,
        jsonrpc3.WithDescription("List all users in the system"),
        jsonrpc3.WithParams(map[string]string{
            "limit":  "number",
            "offset": "number",
        }),
        jsonrpc3.WithCategory("users"),
    )

    adminMethods.Register("get-user", getUser,
        jsonrpc3.WithDescription("Get a specific user by ID"),
        jsonrpc3.WithParams(map[string]string{
            "user_id": "string",
        }),
        jsonrpc3.WithCategory("users"),
    )

    adminMethods.Register("clear-cache", clearCache,
        jsonrpc3.WithDescription("Clear the application cache"),
        jsonrpc3.WithCategory("maintenance"),
    )

    // Create the HTTP handler for JSON-RPC
    rpcHandler := jsonrpc3.NewHTTPHandler(adminMethods)

    // Wrap with auth middleware
    authHandler := authMiddleware(adminToken, rpcHandler)

    // Mount admin endpoint at well-known path
    http.Handle("/.well-known/miren/admin", authHandler)

    log.Printf("Starting server on port %s", port)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

func authMiddleware(token string, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if token != "" {
            auth := r.Header.Get("Authorization")
            if !strings.HasPrefix(auth, "Bearer ") {
                http.Error(w, "Unauthorized", http.StatusUnauthorized)
                return
            }
            if subtle.ConstantTimeCompare(
                []byte(strings.TrimPrefix(auth, "Bearer ")),
                []byte(token),
            ) != 1 {
                http.Error(w, "Unauthorized", http.StatusUnauthorized)
                return
            }
        }
        next.ServeHTTP(w, r)
    })
}

// Sample data
var users = map[string]map[string]any{
    "user-1": {"id": "user-1", "name": "Alice", "email": "alice@example.com"},
    "user-2": {"id": "user-2", "name": "Bob", "email": "bob@example.com"},
}

type listUsersParams struct {
    Limit  int `json:"limit"`
    Offset int `json:"offset"`
}

func listUsers(ctx context.Context, params jsonrpc3.Params, caller jsonrpc3.Caller) (any, error) {
    p := listUsersParams{Limit: 10, Offset: 0}
    if params != nil {
        _ = params.Decode(&p)
    }

    var result []map[string]any
    for _, user := range users {
        result = append(result, user)
    }

    return map[string]any{
        "users": result,
        "total": len(users),
    }, nil
}

type userIDParams struct {
    UserID string `json:"user_id"`
}

func getUser(ctx context.Context, params jsonrpc3.Params, caller jsonrpc3.Caller) (any, error) {
    var p userIDParams
    if params == nil {
        return nil, jsonrpc3.NewInvalidParamsError("user_id is required")
    }
    if err := params.Decode(&p); err != nil {
        return nil, jsonrpc3.NewInvalidParamsError("invalid params")
    }
    if p.UserID == "" {
        return nil, jsonrpc3.NewInvalidParamsError("user_id is required")
    }

    user, ok := users[p.UserID]
    if !ok {
        return nil, jsonrpc3.NewError(-32001, "user not found", nil)
    }

    return user, nil
}

func clearCache(ctx context.Context, params jsonrpc3.Params, caller jsonrpc3.Caller) (any, error) {
    // Your cache clearing logic here
    return map[string]any{
        "cleared": true,
    }, nil
}
```

--------------------------------

### Load a config file

Source: https://miren.md/command/config-load

Example of loading a specific configuration file using the --input flag.

```bash
miren config load --input cluster-config.yaml
```

--------------------------------

### Warm-request trace example

Source: https://miren.md/observability

Example trace output for a warm request where a sandbox is already running. The `httpingress.lease` span shows a cached lease (0.1ms) instead of a cold start, and the proxy-to-app span is the dominant cost.

```text
httpingress                          [15ms]
├─ httpingress.lease                 [0.1ms]  (cached lease)
├─ [proxy to app]                   [14ms]
│  └─ my-app: GET /api/users        [12ms]

```

--------------------------------

### miren config info example

Source: https://miren.md/command/config-info

Displays configuration file locations and format.

```bash
miren config info
```

--------------------------------

### Check server logs in container with docker or podman

Source: https://miren.md/troubleshooting

For container installations (Docker or Podman), follow the Miren container logs. Use whichever runtime you installed with. Note: Podman is daemonless and may not restart after reboot without additional setup.

```bash
docker logs -f miren   # or: podman logs -f miren
```

--------------------------------

### Dockerfile.miren for COBOL with socat

Source: https://miren.md/guides/cobol

Builds the COBOL program with GnuCOBOL and installs socat. The CMD starts socat to listen on $PORT and execute the program per connection.

```dockerfile
FROM debian:12-slim  
  
RUN apt-get update -y \  
    && apt-get install -y gnucobol socat \  
    && apt-get clean && rm -rf /var/lib/apt/lists/*  
  
WORKDIR /app  
COPY hello.cob .  
RUN cobc -x -o /app/hello hello.cob  
  
EXPOSE 8080  
CMD ["sh", "-c", "exec socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:/app/hello"]  

```

--------------------------------

### Initialize and deploy a Go app with Miren

Source: https://miren.md/guides/go

Run these commands from the project root to initialize and deploy the app. Miren auto-detects Go from go.mod and builds the binary.

```bash
miren init  
miren deploy  
```

--------------------------------

### Reveal a sensitive variable

Source: https://miren.md/command/env-get

Example command to get the value of the SECRET_KEY environment variable, using the --unmask flag to show the actual value instead of masking it.

```bash
miren env get SECRET_KEY --unmask
```

--------------------------------

### Example: List runners

Source: https://miren.md/command/runner-list

Lists all registered runners using default settings.

```bash
miren runner list
```

--------------------------------

### Basic deploy

Source: https://miren.md/command/deploy

Deploys the application with default settings, building the image if needed and activating the resulting version. This is the basic form of the command.

```bash
miren deploy
```

--------------------------------

### Dockerfile.miren and .dockerignore for JRuby

Source: https://miren.md/guides/jruby

The Dockerfile.miren builds on the jruby:9.4 image, installs gems with Bundler at build time, and starts Puma on the injected PORT. The .dockerignore excludes .git from the build context.

```dockerfile
FROM jruby:9.4  
WORKDIR /app  
COPY Gemfile ./  
RUN bundle install  
COPY . /app  
EXPOSE 8080  
CMD ["sh", "-c", "exec bundle exec puma -b tcp://0.0.0.0:$PORT"]  


```

```dockerignore
.git  


```

--------------------------------

### Create Dockerfile.miren for Julia

Source: https://miren.md/guides/julia

Required because Miren doesn't auto-detect Julia. Installs and precompiles HTTP during the build to reduce cold-start JIT compile time; the CMD starts the app and no Procfile is needed.

```dockerfile
FROM julia:1.10  
  
WORKDIR /app  
RUN julia -e 'using Pkg; Pkg.add("HTTP"); using HTTP'  
COPY . /app  
  
EXPOSE 8080  
CMD ["julia", "/app/app.jl"]  

```

--------------------------------

### Dockerfile.miren for Mojolicious

Source: https://miren.md/guides/perl

Dockerfile.miren for a Mojolicious app. Installs Mojolicious with cpanm, copies the app, and starts it with the daemon command listening on $PORT. For a cpanfile, use RUN cpanm --notest --installdeps . instead.

```dockerfile
FROM perl:5.40  

WORKDIR /app  
RUN cpanm --notest Mojolicious  
COPY . /app  

EXPOSE 8080  
CMD ["sh", "-c", "exec perl /app/app.pl daemon -l \"http://*:$PORT\""]  

```

--------------------------------

### Example --analyze output showing detected sources

Source: https://miren.md/deployment

Example output from miren deploy --analyze showing the detected source types. Automatic builds name the detected stack, while image deploys show the normalized image reference. The same source appears in miren app status after deployment.

```text
Source: python (auto-detected)
Source: dockerfile
Source: image ghcr.io/example/myapp:latest
```

--------------------------------

### Dockerfile.miren with socat socket front-end

Source: https://miren.md/guides/bash

Dockerfile that installs bash and socat, copies the script, and starts socat to listen on $PORT. Miren injects PORT and socat forks a process per connection. Suited for low-traffic endpoints.

```dockerfile
FROM debian:12-slim  
RUN apt-get update -y && apt-get install -y bash socat && rm -rf /var/lib/apt/lists/*  
WORKDIR /app  
COPY hello.sh .  
RUN chmod +x hello.sh  
EXPOSE 8080  
CMD ["sh", "-c", "exec socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:/app/hello.sh"]  

```

--------------------------------

### Bring a route back: miren route up example.com

Source: https://miren.md/command/route-up

Brings the route for `example.com` out of maintenance and back to serving normally.

```bash
miren route up example.com
```

--------------------------------

### Dockerfile.miren building rebar3 release and running on debian-slim

Source: https://miren.md/guides/erlang

Multi-stage Dockerfile that builds a rebar3 release on erlang:27 and runs it on debian:12-slim. The runtime installs libncurses6 and libssl3 for the bundled ERTS, exposes port 8080, and starts the release in foreground.

```dockerfile
# ----- Build stage -----  
FROM erlang:27 AS builder  
WORKDIR /app  
COPY . .  
RUN rebar3 release  
  
# ----- Runtime stage -----  
FROM debian:12-slim  
RUN apt-get update -y && apt-get install -y libncurses6 libssl3 && rm -rf /var/lib/apt/lists/*  
COPY --from=builder /app/_build/default/rel/erlang_bench /app  
EXPOSE 8080  
CMD ["/app/bin/erlang_bench", "foreground"]  


```

--------------------------------

### Dockerfile.miren for Klong with socat

Source: https://miren.md/guides/klong

Builds the Klong app: installs KlongPy and colorama from PyPI, socat from apt, copies hello.kg, exposes port 8080, and starts the socket front-end with socat. Miren builds from this file instead of guessing the stack.

```dockerfile
FROM python:3.12-slim  
RUN pip install --no-cache-dir klongpy colorama \
    && apt-get update -y && apt-get install -y socat && rm -rf /var/lib/apt/lists/*  
WORKDIR /app  
COPY hello.kg /app/  
EXPOSE 8080  
CMD ["sh", "-c", "exec socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:'kgpy /app/hello.kg'"]  

```

--------------------------------

### Create environment file for DNS provider credentials

Source: https://miren.md/tls

Create an environment file at /var/lib/miren/server/env with the required credentials for the DNS provider. Each provider requires specific environment variables.

```bash
DNSIMPLE_OAUTH_TOKEN=your-token-here
```

--------------------------------

### Scale a pool to 3 instances

Source: https://miren.md/command/sandbox-pool-set-desired

Example shows how to set the desired count to 3 for the pool named web.

```bash
miren sandbox-pool set-desired web 3
```

--------------------------------

### Show route details: miren route show example.com

Source: https://miren.md/command/route-show

Shows details for the route with hostname example.com. This is the basic invocation without any flags.

```bash
miren route show example.com
```

--------------------------------

### Python Flask OpenTelemetry auto-instrumentation setup

Source: https://miren.md/observability

Set up OpenTelemetry auto-instrumentation for a Flask app. Install the required packages, configure the OTLP endpoint and service name in `.miren/app.toml`, and run the app with `opentelemetry-instrument` in a Procfile. The wrapper automatically reads the `traceparent` header and creates spans for Flask routes.

```bash
pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install

```

```toml
[[env]]
key = "OTEL_EXPORTER_OTLP_ENDPOINT"
value = "https://your-otel-collector:4318"

[[env]]
key = "OTEL_SERVICE_NAME"
value = "my-flask-app"

```

```text
# Procfile
web: opentelemetry-instrument flask run --host 0.0.0.0 --port 3000

```

--------------------------------

### miren init command usage

Source: https://miren.md/command/init

Shows the basic command syntax for initializing a new application with miren init. Use this as a reference for the available flags and global options.

```bash
miren init [flags]
```

--------------------------------

### Multi-stage Dockerfile.miren for Node.js app

Source: https://miren.md/guides

Use this multi-stage Dockerfile.miren when your application requires custom build steps, system dependencies, or a language that isn't auto-detected. The first stage installs dependencies and builds the app; the second stage copies the built output and node_modules, exposes port 3000, and starts the server.

```dockerfile
FROM node:20-alpine AS builder  
WORKDIR /app  
COPY package*.json ./  
RUN npm ci  
COPY . .  
RUN npm run build  
  
FROM node:20-alpine  
WORKDIR /app  
COPY --from=builder /app/dist ./dist  
COPY --from=builder /app/node_modules ./node_modules  
EXPOSE 3000  
CMD ["node", "dist/index.js"]  

```

--------------------------------

### Initialize with a specific name

Source: https://miren.md/command/init

Initializes a new application with the specified name 'myapp'. Use the --name flag to override the default directory name.

```bash
miren init --name myapp
```

--------------------------------

### Dockerfile.miren for TruffleRuby with Puma

Source: https://miren.md/guides/truffleruby

Dockerfile.miren for TruffleRuby, based on the official GraalVM community image. It copies the Gemfile, runs bundle install, copies the app, exposes port 8080, and starts Puma bound to 0.0.0.0 on the $PORT environment variable. The CMD is used as the web service's startup default, so no Procfile or service command is needed.

```dockerfile
FROM ghcr.io/graalvm/truffleruby-community:latest  
WORKDIR /app  
COPY Gemfile ./  
RUN bundle install  
COPY . /app  
EXPOSE 8080  
CMD ["sh", "-c", "exec bundle exec puma -b tcp://0.0.0.0:$PORT"]  

```

--------------------------------

### Install Miren skills for Pi

Source: https://miren.md/agent-skills

Install the Miren agent skills for Pi using the pi install command.

```bash
pi install git:github.com/mirendev/miren-skills
```

--------------------------------

### Preview Miren detection with miren deploy --analyze

Source: https://miren.md/guides/go

Use this command to preview what Miren detects — main package, version, entrypoint — without building.

```bash
miren deploy --analyze  
```

--------------------------------

### Install Miren skills for Claude Code

Source: https://miren.md/agent-skills

Install the Miren agent skills for Claude Code by adding the marketplace and installing the plugin.

```bash
/plugin marketplace add mirendev/miren-skills
/plugin install miren@miren
```

--------------------------------

### Check for updates without installing

Source: https://miren.md/command/upgrade

Checks for available updates without installing them.

```bash
miren upgrade --check
```

--------------------------------

### Clone and enter the sample apps demo directory

Source: https://miren.md/getting-started

Clones the Miren sample apps repository and changes into the demo app directory. Use this before running Miren commands on the demo app.

```bash
git clone https://github.com/mirendev/sample-apps.git
cd sample-apps/demo
```

--------------------------------

### Initialize in current directory

Source: https://miren.md/command/init

Initializes a new application in the current directory. The application name defaults to the directory name.

```bash
miren init
```

--------------------------------

### Minimum working example: .miren/app.toml with web and worker services

Source: https://miren.md/services

Defines two services in .miren/app.toml. Both run from the app's primary image; web receives HTTP traffic and worker runs alongside, each scaling independently.

```toml
name = "myapp"

[services.web]
command = "npm start"

[services.worker]
command = "npm run worker"
```
Tokens:
Raw