Juju documentation cover page

Juju is an enterprise Operator Lifecycle Manager (OLM) that provides model-driven application management and next-generation infrastructure-as-code.

The Kubernetes operator pattern replaces configuration file management with software-defined operations and shared, reusable ops code packages. Juju expands this idea to include traditional apps on Windows and Linux.

As a universal operator lifecycle manager for containers, virtual machines and bare metal that manages provisioning and underlying infrastructure, Juju provides a clean approach to multi-cloud operations. Applications can be managed on multiple clouds, and on premise, in machines or on Kubernetes, and then integrated automatically.

Operators are packaged in charms and distributed through Charmhub.io which hosts the Open Operator Collection. A charm is a compressed archive of the operator code and metadata, which can also be shared directly along with applications.

Reusable ops code

We share the code to our open source applications. Why don’t we share the operations code, too?

With traditional configuration management, the architecture of a deployment was hard-coded into the infrastructure-as-code for that operation.

With Juju, the architecture is expressed in a model, which captures the applications, the integration, the machines. Operators discover the model dynamically, which means they can be reused in different models, for different deployments, for different organisations.

Reuse improves quality for any software, and especially operations software, which benefits from application ops experience and hard-to-achieve domain knowledge. Over time, an open source operator reflects deep and wide experience of running that application in a very broad range of contexts.

Model-driven operators

Model-driven operations reduce duplication and errors in complex system administration, allowing administrators to express their intent and having machinery translate that intent to configuration or actions across all the affected applications.

With Juju, operators are deployed together in models, which provide an administrative boundary for permissions and capacity allocation. All the operators in a single model share the same group of administrators, and run on the same cloud or the same Kubernetes cluster.

Automated integration

The Juju model includes an application graph, which declares the lines of integration between applications. Operators drive that integration automatically based on the graph. Administrators can add or remove integration lines dynamically.

Integration can take place within a model, or between applications in different models with the permission of both groups of model administrators. Cross-model integration allows multi-cloud integration, or integration between different substrates such as bare metal Windows and virtualised Kubernetes.

Each operator declares integration endpoints. Integration can be declared between matching endpoints, and code in each operator then handles their end of the integration.

Why Juju?

Juju transforms your ability to integrate fast-moving open source components into large, complex deployments. The move to microservices and the explosion in open source have conspired to make modern operations incredibly complex and dependent on very rare skills. Model-driven operators solve two key problems - application operations domain knowledge is encapsulated in reusable packages, and dynamic model discovery allows reuse of those packages in widely different settings.

  • Multi-cloud operations
    Reusable operations packages mean that you can deploy on multiple clouds without changing operations code. Cross-model integration enables direct integration of workloads on different clouds.

  • Reduced complexity
    Microservices have made applications simpler, but operations more complex. Working at a higher level of abstraction makes it simpler to understand and share complex deployments. Delegating the details to shared open source ops code makes sense.

  • Simplify day two and beyond
    Model-driven operators go beyond the application lifecycle, to handle integration, upgrades, storage, networking, configuration and everyday actions like backup and restore.

  • Optimisation
    Charmed operators are aware of their setting and can optimise the application configuration accordingly.

Last updated 13 days ago. Help improve this document in the forum.