Skip to main content

​
What It Does

Monk’s package ecosystem provides hundreds of pre-built, battle-tested packages for databases, essential services, APIs, and more. These packages are used by Monk’s orchestrator to deploy resources, and by Monk agents to understand and manage every aspect of packaged resources.

​
How It Works

​
What Packages Contain

Monk packages are comprehensive definitions that carry: Deployable workloads:
  • Container-based services (databases, web servers, message queues, etc.)
  • Configuration for running the service
  • Health checks and lifecycle management
Infrastructure definitions:
  • Cloud resource requirements (VMs, storage, networking)
  • Infrastructure blueprints for optimal deployment
  • Multi-cloud compatibility specifications
Custom resource definitions:
  • Interfaces for managing virtually any resource
  • Integration points for third-party services
  • Lifecycle hooks and operational patterns
Extensions for Monk agents:
  • Service-specific behaviors and actions
  • Monitoring and troubleshooting capabilities
  • Cost estimation interfaces

​
Composable by Design

Packages can compose other packages, enabling modular reuse: Example composition:
  • A web application package might compose:
    • PostgreSQL database package
    • Redis cache package
    • Nginx web server package
  • Each sub-package brings its own capabilities and management logic
  • The composed system works as a unified whole
This composability means you don’t reinvent the wheel - build on existing, tested packages.

​
Extensible Without Duplication

Packages are easily extensible through overrides: How it works:
  • Want a custom PostgreSQL configuration? Override the base PostgreSQL package
  • Only define what’s different from the base package
  • Inherit everything else (container setup, health checks, etc.)
Benefits:
  • Less repeated code
  • More succinct definitions
  • Easier to maintain
Example: 
# Instead of defining a complete PostgreSQL package from scratch:
namespace: my-app

postgresql:
  inherits: monk-postgresql # Base PostgreSQL package
  variables:
    max-connections: 200 # Override just what you need
    shared-buffers: "2GB"

​
Programmable with Scripting

Packages can contain arbitrary scripting for complex behaviors: Scripting capabilities:
  • ArrowScript - Monk’s native scripting language for encoding behaviors
  • TypeScript framework - For full customization and complex logic
  • Custom operation patterns - Entirely custom workflows and actions
Use cases:
  • Database backup automation
  • Custom health checks
  • Complex deployment orchestration
  • Service-specific management operations

​
Your Code Becomes Packages

When Monk performs code analysis on your application:
  1. Monk packages up your services - Each component becomes a package definition
  2. Composes with existing packages - Your services combined with databases, caches, etc.
  3. You can review the resulting definition - See the full packaged system
This means your application is treated the same way as pre-built packages - with the same capabilities for deployment, scaling, and management.

​
Content-Addressed & Immutable

Security is built into the package system: Supply chain protection:
  • Content-addressed - Packages identified by cryptographic hash of contents
  • Immutable - Once published, packages cannot be changed
  • Guarded against attacks - Supply chain tampering is prevented by design
Quality assurance:
  • Packages currently permissioned and vetted by Monk team
  • Quality standards enforced before publication
  • Community contributions reviewed and tested

​
The Ecosystem

Current size: Hundreds of packages covering the most common services and infrastructure patterns. Categories:
  • Databases: PostgreSQL, MySQL, MongoDB, Redis, Cassandra, TimescaleDB, CouchDB, Neo4j, and more
  • Message queues: RabbitMQ, Kafka, Mosquitto (MQTT)
  • Storage: MinIO (S3-compatible), IPFS
  • Web servers: Nginx, Apache HTTP Server, HAProxy
  • DevOps tools: Jenkins, GitLab, SonarQube, Nexus, Artifactory
  • Monitoring: Prometheus + Grafana, ELK Stack, TIG Stack, LibreNMS
  • CMS: WordPress, Drupal, Strapi, Directus, DokuWiki
  • Collaboration: Mattermost, Mastodon, Chatwoot, Papercups
  • API & Gateway: Kong, Hasura, Consul
  • Security: HashiCorp Vault, Keycloak, Vaultwarden
  • Data processing: Airflow, Airbyte, Hadoop
  • AI/ML: Ollama, OpenLLM, TensorFlow
  • And 180+ more…
See Integrations for the full list of available packages.

​
Open Source Contributions

Many Monk packages are open source: Contribute and review:
  • GitHub organization: https://github.com/monk-io
  • Review package definitions
  • Submit improvements
  • Contribute new packages
  • Learn from existing implementations
Popular open-source packages: Open source packages provide transparency and allow the community to benefit from and improve Monk’s ecosystem.

​
Coming Soon

Private Packages for Teams COMING SOON Create and share private packages within your organization: What’s coming:
  • Private package repositories - Host packages for your team only
  • Team sharing - Collaborate on package definitions with teammates
  • Version control - Track package versions and changes
  • Access control - Control who can view and use packages
  • Internal integrations - Package your proprietary services
See Team Collaboration for more on upcoming team features.

​
What Makes This Different

Traditional infrastructure management requires:
  • Writing custom deployment scripts for every service
  • Manually configuring each component from scratch
  • Duplicating configuration across similar services
  • Learning service-specific operational patterns
  • No reusability between projects
  • Managing dependencies manually
With Monk’s Package Ecosystem:
  • Hundreds of pre-built, battle-tested packages
  • Compose packages to build complex systems
  • Extend existing packages without duplication
  • Programmable with scripting for custom needs
  • Your code packaged the same way as everything else
  • Supply chain security built in
  • Open source and community-driven

​
Key Capabilities

  • ✅ Hundreds of packages - Databases, services, DevOps tools, CMS, and more
  • ✅ Comprehensive definitions - Workloads, infrastructure, custom resources
  • ✅ Used by orchestrator - See Containerization & Orchestration
  • ✅ Used by agents - Monk understands and manages packaged resources
  • ✅ Composable - Packages compose other packages for modularity
  • ✅ Extensible - Override and customize without duplication
  • ✅ Programmable - ArrowScript and TypeScript for complex behaviors
  • ✅ Content-addressed - Cryptographic hashes prevent supply chain attacks
  • ✅ Immutable - Published packages cannot be tampered with
  • ✅ Vetted by Monk - Quality-assured and permissioned
  • ✅ Many open source - Review and contribute on GitHub
  • ✅ Your code packaged - Code analysis creates packages for your services
Coming Soon:
  • 🔜 Private packages - Team-specific package repositories
  • 🔜 Team collaboration - Share packages within your organization

​
Impact

Deploy complex services with one command. Compose pre-built packages to build sophisticated systems. Extend and customize without reinventing the wheel. Your application treated as first-class packages, just like everything else in the ecosystem.