Komodo

https://komo.do/docs
Admin
The purpose and key features of the Komodo project could not be determined from the provided 'Page...
Tokens:30,193
Snippets:340
Trust Score:7.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Periphery Agent

Source: https://komo.do/docs/setup/connect-servers

Use the setup script to install the Periphery agent as a systemd service. Choose between root or user-level installation based on your requirements.

```bash
curl -sSL https://raw.githubusercontent.com/moghtech/komodo/main/scripts/setup-periphery.py \
  | python3 - \
  --core-address="https://<core-address>" \
  --connect-as="$(hostname)" \
  --onboarding-key="O-..."
```

```bash
curl -sSL https://raw.githubusercontent.com/moghtech/komodo/main/scripts/setup-periphery.py \
  | python3 - --user \
  --core-address="https://<core-address>" \
  --connect-as="$(hostname)" \
  --onboarding-key="O-..."
```

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

### Install Rust CLI Tools and Link Client

Source: https://komo.do/docs/ecosystem/development

Updates the Rust toolchain and installs necessary CLI tools like typeshare and runnables, then links the client. Ensure Rust is installed via rustup.

```bash
rustup update  
cargo install typeshare-cli runnables-cli  
run link-client  

```

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

### Set up Docker Buildx Builder

Source: https://komo.do/docs/build

Create and use a Docker Buildx builder for multi-platform builds. Ensure Buildx is installed to make it the default for Docker builds.

```bash
docker buildx create --name builder --use --bootstrap
```

```bash
docker buildx install
```

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

### Start Docusaurus Docs Site

Source: https://komo.do/docs/ecosystem/development

Launches the Docusaurus documentation site in development mode. Changes to files in `./docsite` will trigger automatic reloads.

```bash
run dev-docsite

```

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

### Periphery Start Commands

Source: https://komo.do/docs/setup/connect-servers

Commands to start the Periphery binary directly or via Docker configuration overrides.

```bash
periphery --config-path /path/to/periphery.config.toml  
```

```yaml
command: periphery --config-path /path/in/container/to/periphery.config.base.toml  
```

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

### Create Local Config Directories

Source: https://komo.do/docs/ecosystem/development

Creates necessary directories for local configuration files. Ensure these directories exist before proceeding with local setup.

```bash
mkdir -p .dev/keys .dev/periphery  

```

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

### Install Komodo CLI on Linux

Source: https://komo.do/docs/ecosystem/cli

Install the Komodo CLI binary system-wide or for the current user using a Python script.

```bash
curl -sSL https://raw.githubusercontent.com/moghtech/komodo/main/scripts/install-cli.py | python3

```

```bash
curl -sSL https://raw.githubusercontent.com/moghtech/komodo/main/scripts/install-cli.py | python3 - --user

```

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

### Install Docker on EC2 Instance

Source: https://komo.do/docs/build

Commands to update the package list, upgrade existing packages, and install Docker on an EC2 instance. Ensure Docker services are enabled to start on boot.

```bash
apt update && apt upgrade -y
curl -fsSL https://get.docker.com | sh
systemctl enable docker.service containerd.service
```

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

### Install Komodo CLI on MacOS with Homebrew

Source: https://komo.do/docs/ecosystem/cli

Install the Komodo CLI using Homebrew by tapping the repository and then installing the `km` package.

```bash
brew tap moghtech/komodo && \
  brew install km

```

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

### Cron Schedule Examples

Source: https://komo.do/docs/automate/schedules

Examples of cron expressions for various scheduling needs. Note the inclusion of seconds in all examples.

```text
0 0 3 * * ?

```

```text
0 */5 * * * ?

```

```text
0 0 0 1,15 * ?

```

```text
0 0 9 ? * MON

```

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

### Git Provider Configuration

Source: https://komo.do/docs/configuration/providers

Example configuration for defining git providers in TOML format.

```toml
# in core.config.toml or periphery.config.toml

[[git_provider]]
domain = "github.com"
accounts = [
  { username = "my-user", token = "ghp_xxxxxxxxxxxx" },
]

[[git_provider]]
domain = "git.example.com" # self-hosted Gitea, GitLab, etc.
accounts = [
  { username = "my-user", token = "access_token" },
]

[[git_provider]]
domain = "localhost:3000"
https = false # clone over http://
accounts = [
  { username = "my-user", token = "access_token" },
]
```

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

### Start MongoDB Instance with Docker

Source: https://komo.do/docs/ecosystem/development

Launches a MongoDB instance in a Docker container for Komodo's database. This command maps the port and mounts volumes for data persistence.

```bash
docker run -d --name komodo-mongo \
-p 27017:27017 \
-v komodo-mongo-data:/data/db \
-v komodo-mongo-config:/data/configdb \
-e MONGO_INITDB_ROOT_USERNAME=komodo \
-e MONGO_INITDB_ROOT_PASSWORD=komodo \
mongo  

```

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

### Docker Registry Configuration

Source: https://komo.do/docs/configuration/providers

Example configuration for defining docker registries in TOML format.

```toml
# in core.config.toml or periphery.config.toml

[[image_registry]]
domain = "docker.io"
accounts = [
  { username = "my-user", token = "dckr_pat_xxxxxxxxxxxx" },
]
organizations = ["MyOrg"]

[[image_registry]]
domain = "ghcr.io"
accounts = [
  { username = "my-user", token = "ghp_xxxxxxxxxxxx" },
]

[[image_registry]]
domain = "registry.example.com" # self-hosted registry
accounts = [
  { username = "my-user", token = "access_token" },
]
organizations = ["MyTeam"]
```

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

### Deploy Komodo Stack

Source: https://komo.do/docs/setup/mongo

Execute the Docker Compose command to start the MongoDB, Core, and Periphery services.

```bash
docker compose -p komodo -f komodo/mongo.compose.yaml --env-file komodo/compose.env up -d
```

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

### Enable Periphery Service

Source: https://komo.do/docs/setup/connect-servers

Commands to ensure the Periphery service starts automatically on boot or persists after user logout.

```bash
sudo systemctl enable periphery
```

```bash
sudo loginctl enable-linger $USER
```

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

### Run Komodo Core Service

Source: https://komo.do/docs/ecosystem/development

Starts the Komodo core service using the runnables CLI. This command assumes the necessary configuration is in place.

```bash
run dev-core  

```

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

### Interpolate Variable Values

Source: https://komo.do/docs/configuration/variables

Demonstrates how to use double brackets to interpolate a defined variable's value into another configuration setting. The example shows the syntax before and after interpolation.

```plaintext
# Before interpolation
SOME_ENV_VAR = [[KEY_1]] # <- wrap the key in double brackets '[[]]'
  
# After interpolation:  
SOME_ENV_VAR = value_1
```

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

### Run Komodo Periphery Service

Source: https://komo.do/docs/ecosystem/development

Starts the Komodo periphery service using the runnables CLI. This command assumes the necessary configuration is in place.

```bash
run dev-periphery  

```

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

### Configure Scheduled Database Backup Procedure

Source: https://komo.do/docs/setup/backup

Define a TOML procedure for daily database backups. This is automatically created in new installs (v1.19.0+).

```toml
[[procedure]]
name = "Backup Core Database"
description = "Triggers the Core database backup at the scheduled time."
tags = ["system"]
config.schedule = "Every day at 01:00"

[[procedure.config.stage]]
name = "Stage 1"
enabled = true
executions = [
  { execution.type = "BackupCoreDatabase", execution.params = {}, enabled = true }
]

```

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

### Download Default Configuration File

Source: https://komo.do/docs/setup/advanced

Use wget to download the official default configuration template to your local directory.

```bash
wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/config/core.config.toml  
```

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

### Download FerretDB Configuration Files

Source: https://komo.do/docs/setup/ferretdb

Use wget to fetch the required Docker Compose and environment files from the Komodo repository.

```bash
wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/compose/ferretdb.compose.yaml && \
  wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/compose/compose.env
```

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

### Download Komodo Configuration Files

Source: https://komo.do/docs/setup/mongo

Use wget to fetch the required Docker Compose and environment files from the Komodo repository.

```bash
wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/compose/mongo.compose.yaml && \
  wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/compose/compose.env
```

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

### Download Default Configuration

Source: https://komo.do/docs/setup/connect-servers

Use wget to download the default periphery.config.toml file to the local komodo directory.

```bash
wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/config/periphery.config.toml
```

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

### Declare a Server Resource

Source: https://komo.do/docs/automate/sync-resources

Define a new server resource with its name, description, tags, and configuration details like address and region. Ensure the 'enabled' flag is set appropriately.

```toml
[[server]] # Declare a new server  
name = "server-prod"  
description = "the prod server"  
tags = ["prod"]  
[server.config]  
address = "http://localhost:8120"  
region = "AshburnDc1"  
enabled = true # default: false  
```

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

### Initialize Docker Swarm

Source: https://komo.do/docs/swarm

Initialize a new Docker Swarm on a server. Replace '<SERVER_IP>' with the actual IP address of the server.

```bash
docker swarm init --advertise-addr <SERVER_IP>
```

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

### Include Configuration Files

Source: https://komo.do/docs/ecosystem/cli

Use a `.kminclude` file to specify additional directories where the CLI should search for configuration files. Wildcards are not supported in these paths.

```bash
# Supports comments  
  
./.komodo    # relative to directory containing `.kminclude`  
  
/etc/komodo/komodo.cli.toml  # also supports absolute path  


```

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

### Run Komodo UI in Development Mode

Source: https://komo.do/docs/ecosystem/development

Starts the Komodo UI in development mode with hot-reloading enabled using the runnables CLI. This command is used for frontend development.

```bash
run dev-ui      # Start in dev (watch) mode  

```

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

### UI and System Configuration

Source: https://komo.do/docs/setup/advanced

Settings to control UI behavior and internal system paths.

```toml
disable_confirm_dialog = false
disable_websocket_reconnect = false
disable_init_resources = false
sync_directory = "/syncs"
repo_directory = "/repo-cache"
action_directory = "/action-cache"
internet_interface = ""
```

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

### Configure AWS EC2 Builder in Komodo

Source: https://komo.do/docs/build

Define an AWS EC2 builder configuration for Komodo. This includes specifying region, instance type, AMI, networking details, and user data for agent setup.

```toml
[[builder]]
name = "builder-01"
[builder.config]
type = "Aws"
params.region = "us-east-2"
params.instance_type = "c5.2xlarge"
params.ami_id = "ami-xxxxxxxxxxxxxxxxxx"
params.subnet_id = "subnet-xxxxxxxxxxxxxxxxxx"
params.key_pair_name = "ssh-key"
params.assign_public_ip = true ## Required for outbound internet access unless you have network gateway. 
params.use_public_ip = true ## Setting 'false' uses the private IP (when Komodo Core is in same subnet). 
params.security_group_ids = ["sg-xxxxxxxxxxxxxxxxxx"]
params.user_data = """
#!/bin/bash
curl -sSL \
   https://raw.githubusercontent.com/moghtech/komodo/main/scripts/setup-periphery.py | \
  HOME=/root python3 - --version=v2.X.X
"""

```

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

### Declare Deployment Resources with Variables and Dependencies

Source: https://komo.do/docs/automate/sync-resources

Define deployment resources, including variables that can be interpolated into environment variables. Deployments can be configured with server, image, volumes, and environment variables. Dependencies between deployments can be established using the 'after' field.

```toml
# Declare variables  
[[variable]]  
name = "OTLP_ENDPOINT"  
value = "http://localhost:4317"  
  
##  
  
[[deployment]] # Declare a deployment  
name = "test-logger-01"  
description = "test logger deployment 1"  
tags = ["test"]  
# sync will deploy the container:  
#  - if it is not running.  
#  - has relevant config updates.  
#  - the attached build has new version.  
deploy = true  
[deployment.config]  
server = "server-01"  
image.type = "Build"  
image.params.build = "test_logger"  
# set the volumes / bind mounts  
volumes = """  
# Supports comments  
/data/logs = /etc/logs  
# And other formats (eg yaml list)  
- "/data/config:/etc/config"  
"""  
# Set the environment variables  
environment = """  
# Comments supported  
OTLP_ENDPOINT = [[OTLP_ENDPOINT]] # interpolate variables into the envs.  
VARIABLE_1 = value_1  
VARIABLE_2 = value_2  
"""  
# Set Docker labels  
labels = "deployment.type = logger"  
  
##  
  
[[deployment]]  
name = "test-logger-02"  
description = "test logger deployment 2"  
tags = ["test"]  
deploy = true  
# Create a dependency on test-logger-01. This deployment will only be deployed after test-logger-01 is deployed.  
# Additionally, any sync deploy of test-logger-01 will also trigger sync deploy of this deployment.  
after = ["test-logger-01"]  
[deployment.config]  
server = "server-01"  
image.type = "Build"  
image.params.build = "test_logger"  
volumes = """  
/data/logs = /etc/logs  
/data/config = /etc/config"""  
environment = """  
VARIABLE_1 = value_1  
VARIABLE_2 = value_2  
"""  
# Set Docker labels  
labels = "deployment.type = logger"  
```

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

### Deploy Komodo with Docker Compose

Source: https://komo.do/docs/setup/ferretdb

Execute the deployment command using the downloaded configuration and environment files.

```bash
docker compose -p komodo -f komodo/ferretdb.compose.yaml --env-file komodo/compose.env up -d
```

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

### Git Clone Command Patterns

Source: https://komo.do/docs/configuration/providers

Standard command formats for cloning private repositories using authentication tokens.

```bash
git clone https://<Username>:<Token>@<domain>/<Owner>/<Repo>
```

```bash
git clone https://<Token>@<domain>/<Owner>/<Repo>
```

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

### Stack Configuration Schema

Source: https://komo.do/docs/automate/sync-resources

Defines a stack with its name, description, deployment status, dependencies, tags, and configuration details like server, file paths, and Git provider.

```toml
[[stack]]
name = "test-stack"
description = "stack test"
deploy = true
after = ["test-logger-01"] # Stacks can depend on deployments, and vice versa.
tags = ["test"]
[stack.config]
server = "server-prod"
file_paths = ["mongo.yaml", "redis.yaml"]
git_provider = "git.mogh.tech"
git_account = "mbecker20" # clone private repo by specifying account
repo = "mbecker20/stack_test"

```

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

### Download Default Komodo CLI Configuration

Source: https://komo.do/docs/ecosystem/cli

Quickly download the default Komodo CLI TOML configuration file to a specified directory using `wget`.

```bash
wget -P komodo https://raw.githubusercontent.com/moghtech/komodo/main/config/komodo.cli.toml
```

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

### Configure Git Providers

Source: https://komo.do/docs/setup/advanced

Authentication details for private repository cloning.

```toml
# [[git_provider]]
# domain = "github.com"
# accounts = [
# 	{ username = "mbecker20", token = "access_token_for_account" },
# 	{ username = "moghtech", token = "access_token_for_other_account" },
# ]
  
# [[git_provider]]
# domain = "git.mogh.tech" # use a custom provider, like self-hosted gitea
# accounts = [
# 	{ username = "mbecker20", token = "access_token_for_account" },
# ]
  
# [[git_provider]]
# domain = "localhost:8000" # use a custom provider, like self-hosted gitea
# https = false # use http://localhost:8000 as base-url for clone
# accounts = [
# 	{ username = "mbecker20", token = "access_token_for_account" },
# ]
```

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

### Configure Docker Build and Registry

Source: https://komo.do/docs/build

This configuration block defines a build named 'my-app', specifying the builder, Git repository, and image registry details for pushing the built Docker image.

```hcl
[[build]]
name = "my-app"
[build.config]
builder = "builder-01"
repo = "myorg/my-app"
branch = "main"
git_account = "my-user"
image_registry = [
  { domain = "ghcr.io", account = "my-user", organization = "my-org" }
]

```

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

### View Komodo CLI Configuration

Source: https://komo.do/docs/ecosystem/cli

Use the `km config` command to display the current configuration, showing how settings are loaded from files, environment variables, and CLI arguments.

```bash
km config

```

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

### Repo Configuration Schema

Source: https://komo.do/docs/automate/sync-resources

Defines a repository with its name, description, tags, and configuration for Git provider, account, and repository. Includes an 'on_pull' command to run after the repo is pulled.

```toml
[[repo]]
name = "komodo-periphery"
description = "Builds new versions of the periphery binary. Requires Rust installed on the host."
tags = ["komodo"]
[repo.config]
server = "server-01"
git_provider = "git.mogh.tech" # use an alternate git provider (default is github.com)
git_account = "mbecker20"
repo = "moghtech/komodo"
# Run an action after the repo is pulled
on_pull.path = "."
on_pull.command = """
# Supports comments
/root/.cargo/bin/cargo build -p komodo_periphery --release
# Multiple lines will be combined together using '&&'
cp ./target/release/periphery /root/periphery
"""


```

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

### Authentication Configuration

Source: https://komo.do/docs/setup/connect-servers

Settings for defining private keys, core public keys, and legacy passkeys for authentication.

```toml
# private_key = "file:/path/to/file"
# core_public_keys = "MCowBQYDK2VuAyEATZgrjGHeF0KJUe0+n77+qAWOg3YzEzXOmQWaRgO3OGQ=, file:/path/to/key2.pub"
# passkeys = ["default-passkey"]
```

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

### Attach to Container Main Process

Source: https://komo.do/docs/ecosystem/cli

Use `km attach` to connect to a running container's main process stdio, analogous to `docker attach`.

```bash
km attach <container> [options]

```

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

### Authentication and User Management

Source: https://komo.do/docs/setup/advanced

Settings for managing local authentication, admin initialization, and user registration policies.

```toml
local_auth = false
min_password_length = 1
# init_admin_username = "admin"
init_admin_password = "changeme"
disable_user_registration = false
# disable_local_user_registration = true
# disable_oidc_user_registration = true
enable_new_users = false
transparent_mode = false
disable_non_admin_create = false
```

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

### Declare Builder and Build Resources

Source: https://komo.do/docs/automate/sync-resources

Define a builder resource, specifying its type (e.g., 'Aws') and configuration parameters like region and AMI ID. Subsequently, declare a build resource, linking it to a builder and specifying the repository, branch, and image registry details. Custom Docker labels can also be set.

```toml
[[builder]] # Declare a builder  
name = "builder-01"  
tags = []  
config.type = "Aws"  
[builder.config.params]  
region = "us-east-2"  
ami_id = "ami-0e9bd154667944680"  
# These things come from your specific setup  
subnet_id = "subnet-xxxxxxxxxxxxxxxxxx"  
key_pair_name = "xxxxxxxx"  
assign_public_ip = true  
use_public_ip = true  
security_group_ids = [  
  "sg-xxxxxxxxxxxxxxxxxx",  
  "sg-xxxxxxxxxxxxxxxxxx"  
]  
  
##  
  
[[build]]  
name = "test_logger"  
description = "Logs randomly at INFO, WARN, ERROR levels to test logging setups"  
tags = ["test"]  
[build.config]  
builder = "builder-01"  
repo = "mbecker20/test_logger"  
branch = "master"  
git_account = "mbecker20"  
image_registry.type = "Standard"  
image_registry.params.domain = "github.com" # or your custom domain  
image_registry.params.account = "your_username"  
image_registry.params.organization = "your_organization" # optional  
# Set docker labels  
labels = """  
org.opencontainers.image.source = https://github.com/mbecker20/test_logger  
org.opencontainers.image.description = Logs randomly at INFO, WARN, ERROR levels to test logging setups  
org.opencontainers.image.licenses = GPL-3.0  
"""  
```

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

### Environment Variables Configuration

Source: https://komo.do/docs/setup/mongo

Configuration file for defining database credentials, image tags, and backup paths for the Komodo deployment.

```text
####################################  
# 🦎 KOMODO COMPOSE - VARIABLES 🦎 #  
####################################  
  
## These compose variables can be used with all Komodo deployment options.  
## Pass these variables to the compose up command using `--env-file komodo/compose.env`.  
## Additionally, they are passed to both Komodo Core and Komodo Periphery with `env_file: ./compose.env`,  
## so you can pass any additional environment variables to Core / Periphery directly in this file as well.  
  
## Follows "major.minor.patch" semver.  
COMPOSE_KOMODO_IMAGE_TAG="2"  
## Store dated database backups on the host - https://komo.do/docs/setup/backup  
COMPOSE_KOMODO_BACKUPS_PATH=/etc/komodo/backups  
  
## DB credentials  
KOMODO_DATABASE_USERNAME=admin  
KOMODO_DATABASE_PASSWORD=admin  
  
## Set your time zone for schedules  
## https://en.wikipedia.org/wiki/List_of_tz_database_time_zones  
TZ=Etc/UTC  
  
#=-------------------------=#  
#= Komodo Core Environment =#  
#=-------------------------=#  
```

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

### Migrate Terminal Execution to v2

Source: https://komo.do/docs/releases/v2.0.0

Replaces the two-step terminal creation and execution pattern with a single streamlined call using the init option.

```javascript
// This took 2 calls in v1  
await komodo.write("CreateTerminal", {  
  server: "my-server",  
  name: "my-terminal",  
  command: "bash",  
  recreate: "Always",  
});  
await komodo.execute_terminal(  
  { server: "my-server", terminal: "my-terminal", command: "ls -l" },  
  { onLine: (line) => console.log(line) },  
);
```

```javascript
// Streamlined terminal execute with init options.  
await komodo.execute_server_terminal(  
  {  
    server: "my-server",  
    terminal: "my-terminal",  
    command: "ls -l",  
    init: { command: "bash", recreate: "Always" },  
  },  
  { onLine: (line) => console.log(line) },  
);
```

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

### Restart deployments matching tags

Source: https://komo.do/docs/automate/procedures

Read a list of deployments based on tags and then execute a restart for each. Ensure the `komodo.read` and `komodo.execute` methods are used correctly.

```typescript
const deployments = await komodo.read("ListDeployments", {
  query: { tags: ["backend"] },
});

for (const deployment of deployments) {
  await komodo.execute("RestartDeployment", {
    deployment: deployment.name,
  });
  console.log(`Restarted ${deployment.name}`);
}

```

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

### Configure Logging and Telemetry

Source: https://komo.do/docs/setup/advanced

Settings for standard output, OTLP endpoints, and service naming conventions.

```toml
logging.stdio = "standard"
  
## Optionally specify a opentelemetry otlp endpoint to send traces to.  
## Example: http://localhost:4317  
## Env: KOMODO_LOGGING_OTLP_ENDPOINT  
logging.otlp_endpoint = ""
  
## Set the opentelemetry service name.  
## This will be attached to the telemetry Komodo will send.  
## Env: KOMODO_LOGGING_OPENTELEMETRY_SERVICE_NAME  
## Default: "Komodo"  
logging.opentelemetry_service_name = "Komodo"
  
## Set the opentelemetry scope name.  
## This will be attached to the telemetry Komodo will send.  
## Env: KOMODO_LOGGING_OPENTELEMETRY_SCOPE_NAME  
## Default: "Komodo"  
logging.opentelemetry_scope_name = "Komodo"
  
## Specify whether logging is more human readable.  
## Note. Single logs will span multiple lines.  
## Env: KOMODO_LOGGING_PRETTY  
## Default: false  
logging.pretty = false
  
## Specify whether startup config log  
## is more human readable (multi-line)  
## Env: KOMODO_PRETTY_STARTUP_CONFIG  
## Default: false  
pretty_startup_config = false
```

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

### Specify Target Platforms for Buildx

Source: https://komo.do/docs/build

Pass the desired target platforms to the build command using the --platform flag in the Extra Args.

```bash
--platform linux/amd64,linux/arm64
```

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

### Configure Multiple Image Registries

Source: https://komo.do/docs/build

Specify a list of Docker-compatible registries to push images to simultaneously. Each entry requires a domain and account, with an optional organization.

```toml
[build.config]
image_registry = [
  { domain = "ghcr.io", account = "my-user", organization = "my-org" },
  { domain = "docker.io", account = "my-user" },
]

```

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

### Configure Authentication and JWT Settings

Source: https://komo.do/docs/setup/advanced

Settings for managing login credentials, JWT secrets, and session duration.

```toml
lock_login_credentials_for = []

## Optionally provide a specific jwt secret.
## Passing nothing or an empty string will cause one to be generated on every startup.
## This means users will have to log in again if Komodo restarts.
## Env: KOMODO_JWT_SECRET or KOMODO_JWT_SECRET_FILE
## Default: empty string, meaning a random secret will be generated at startup.
jwt_secret = ""

## Specify how long a user can stay logged in before they have to log in again.
## All jwts are invalidated on application restart unless `jwt_secret` is set.
## Env: KOMODO_JWT_TTL
## Options: https://docs.rs/komodo_client/latest/komodo_client/entities/enum.Timelength.html
## Default: 1-day.
jwt_ttl = "1-day"
```

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

### Initialize Komodo Typescript Client and List Stacks

Source: https://komo.do/docs/ecosystem/api

Initializes the Komodo Typescript client using API key authentication and retrieves a list of stacks. Ensure you provide the correct key and secret.

```typescript
import { KomodoClient, Types } from "komodo_client";  
  
const komodo = KomodoClient("https://demo.komo.do", {  
  type: "api-key",  
  params: {  
    key: "your_key",  
    secret: "your secret",  
  },
});  
  
// Inferred as Types.StackListItem[]  
const stacks = await komodo.read("ListStacks", {});
```

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

### Configure OAuth Providers

Source: https://komo.do/docs/setup/advanced

Settings for enabling Google and Github OAuth authentication.

```toml
## Google

## Env: KOMODO_GOOGLE_OAUTH_ENABLED
## Default: false
google_oauth.enabled = false

## Env: KOMODO_GOOGLE_OAUTH_ID or KOMODO_GOOGLE_OAUTH_ID_FILE
## Required if google_oauth is enabled.
google_oauth.id = ""

## Env: KOMODO_GOOGLE_OAUTH_SECRET or KOMODO_GOOGLE_OAUTH_SECRET_FILE
## Required if google_oauth is enabled.
google_oauth.secret = ""

## Github

## Env: KOMODO_GITHUB_OAUTH_ENABLED
## Default: false
github_oauth.enabled = false

## Env: KOMODO_GITHUB_OAUTH_ID or KOMODO_GITHUB_OAUTH_ID_FILE
## Required if github_oauth is enabled.
github_oauth.id = ""

## Env: KOMODO_GITHUB_OAUTH_SECRET or KOMODO_GITHUB_OAUTH_SECRET_FILE
## Required if github_oauth is enabled.
github_oauth.secret = ""
```

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

### Inbound Mode Configuration

Source: https://komo.do/docs/setup/connect-servers

Settings for enabling and configuring the local server for inbound connections.

```toml
# server_enabled = true
port = 8120
bind_ip = "[::]"
allowed_ips = []
ssl_enabled = true
# ssl_key_file = "/etc/komodo/ssl/key.pem"
# ssl_cert_file = "/etc/komodo/ssl/cert.pem"
```

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

### Core Configuration File

Source: https://komo.do/docs/ecosystem/development

Defines the configuration for the Komodo core service when running locally. This includes host, key paths, authentication, and database settings.

```toml
host = "http://localhost:9120"  
private_key = "file:.dev/keys/core.key"  
local_auth = true  
enable_new_users = true  
jwt_secret = "a_random_secret"  
first_server_address = "http://localhost:8120"  
cors_allowed_origins = ["http://localhost:5173"]  
cors_allow_credentials = true  
session_allow_cross_site = true  
  
database.address = "localhost:27017"  
database.username = "komodo"  
database.password = "komodo"  


```

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

### Resource Sync Configuration Schema

Source: https://komo.do/docs/automate/sync-resources

Configures resource synchronization, specifying the Git provider, account, repository, and the paths to the resources to be synchronized.

```toml
[[resource_sync]]
name = "resource-sync"
[resource_sync.config]
git_provider = "git.mogh.tech" # use an alternate git provider (default is github.com)
git_account = "mbecker20"
repo = "moghtech/komodo"
resource_path = ["stacks.toml", "repos.toml"]


```

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

### Configure AWS Cloud Provider

Source: https://komo.do/docs/setup/advanced

Credentials for ephemeral AWS EC2 build instances.

```toml
aws.access_key_id = ""
## Env: KOMODO_AWS_SECRET_ACCESS_KEY or KOMODO_AWS_SECRET_ACCESS_KEY_FILE  
aws.secret_access_key = ""
```

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

### UI Development Environment Variables

Source: https://komo.do/docs/ecosystem/development

Sets the environment variable for the UI to connect to the Komodo host during development. This file should be placed in the `ui/` directory.

```env
VITE_KOMODO_HOST=http://localhost:9120  

```

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

### Configure Public Key Authentication

Source: https://komo.do/docs/releases/v2.0.0

Set the core_public_keys parameter in the periphery configuration to enable public key authentication. This accepts Spki base64 DER or a path to a PEM file.

```toml
## Accepted public keys to allow Core(s) to connect.  
## Periphery gains knowledge of the Core public key through the noise handshake.  
## If neither these nor passkeys provided, inbound connections will not be authenticated.  
## Accepts Spki base64 DER directly and PEM file. Use `file:/path/to/core.pub` to load from file.  
## Env: PERIPHERY_CORE_PUBLIC_KEYS  
## Optional, no default.  
core_public_keys = "<YOUR_CORE_PUBLIC_KEY>"  
```

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

### Komodo Core Configuration Template

Source: https://komo.do/docs/setup/advanced

The default TOML configuration file for Komodo Core, documenting all available settings and environment variable overrides.

```toml
###########################  
# 🦎 KOMODO CORE CONFIG 🦎 #  
###########################  
  
## This is the offical "Default" config file for Komodo Core.  
## It serves as documentation for the meaning of the fields.  
## It is located at `https://github.com/moghtech/komodo/blob/main/config/core.config.toml`.  
  
## All fields with a "Default" provided are optional. If they are  
## left out of the file, the "Default" value will be used.  
  
## This file is bundled into the official image, `ghcr.io/moghtech/komodo-core`,  
## as the default config at `/config/.default.config.toml`.  
## Komodo Core can start with no external config file mounted.  
  
## Most fields can also be configured using environment variables.  
## Environment variables will override values set in this file.  
  
## Can also use JSON or YAML if preferred. You can convert here:  
##   - YAML: https://it-tools.tech/toml-to-yaml  
##   - JSON: https://it-tools.tech/toml-to-json  
  
## This will be the document title on the web page.  
## Env: KOMODO_TITLE  
## Default: 'Komodo'  
title = "Komodo"  
  
## This should be the url used to access Komodo in browser, potentially behind DNS.  
## Eg https://komodo.example.com or http://12.34.56.78:9120. This should match the address configured in your Oauth app.  
## Env: KOMODO_HOST  
## Required, no default.  
host = "https://komodo.example.com"  
  
## The port the core system will run on.  
## Env: KOMODO_PORT  
## Default: 9120  
port = 9120  
  
## The IP address the core server will bind to.  
## The default will allow it to accept external IPv4 and IPv6 connections.  
## Env: KOMODO_BIND_IP  
## Default: [::]  
bind_ip = "[::]"  
  
## Default private key to use with Noise handshake to authenticate with Periphery agents.  
## If using `file:/path/to/file` and the file doesn't exist yet,  
## Core will generate and write new key to the path.  
## Env: KOMODO_PRIVATE_KEY or KOMODO_PRIVATE_KEY_FILE  
## Default: file:/config/keys/core.key  
private_key = "file:/config/keys/core.key"  
  
## Default accepted public key to allow Periphery to connect.  
## If not provided, Periphery -> Core connected Servers must  
## configure accepted public keys individually.  
##  
## Accepts public keys files using `file:/path/to/periphery.pub`  
##  
## Note: If used, the public key can still be overridden on individual Servers / Builders  
##  
## Env: KOMODO_PERIPHERY_PUBLIC_KEY  
## Default: None  
# periphery_public_key = "file:/config/keys/periphery.pub"  
  
## Deprecated. Legacy v1 compatibility.  
## Users should upgrade to private / public key authentication.  
## Env: KOMODO_PASSKEY  
# passkey = "default-passkey"  
  
## Give the first server a custom name.  
## If this is set but 'first_server_address' is not,  
## will assume Periphery -> Core connection.  
## Env: KOMODO_FIRST_SERVER_NAME  
## Default: None  
# first_server_name = "${HOSTNAME}"  
  
## Ensure a server with this address exists on Core  
## upon first startup. Example: `https://periphery:8120`  
## Env: KOMODO_FIRST_SERVER_ADDRESS  
## Optional, no default.  
# first_server_address = ""  
  
## Set the default pagination limit for the API and UI to use.  
## Env: KOMODO_DEFAULT_PAGINATION_LIMIT  
## Default: 50  
default_pagination_limit = 50  
  
## Disables write support on resources in the UI.  
## This protects users that that would normally have write priviledges during their UI usage,  
## when they intend to fully rely on ResourceSyncs to manage config.  
## Env: KOMODO_UI_WRITE_DISABLED  
## Default: false  
ui_write_disabled = false  
```
Tokens:
Raw