# Entando Deployment Structure
This page provides a high level overview of the key Entando GitHub repositories along with a brief description of how those repositories are realized in a running Entando deployment. The descriptions provided here are meant as a guide for identifying opportunities to dig deeper into the architecture and how things are structured rather than a panacea for understanding the architecture.
The Entando operator coordinates the installation and configuration of all of the components of an Entando Cluster. The operator can be installed once per Entando Cluster and used to coordinate the plugin lifecycle for multiple Entando applications across many namespaces.
- GitHub: https://github.com/entando-k8s/entando-k8s-controller-coordinator/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-k8s-controller-coordinator (opens new window)
It is unlikely that the operator will be customized as part of an Entando implementation. It is not built to be extended inside the codebase. The most common pattern will be to use the existing custom resources that the operator knows how to deploy to extend the Entando platform.
# database init containers
During installation an Entando application needs to create several databases and also to initialize those databases with information when deploying from a backup in your images. At initialization the entando-k8s-dbjob will be run 5 times in total. Once for keycloak, twice for the entando application (port and serv dbs), once to populate the Entando application database, and once to create the Component Repository database.
- GitHub: https://github.com/entando-k8s/entando-k8s-dbjob (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-k8s-dbjob (opens new window)
The screenshot below highlights the init containers for the Entando application schema creation, db initialization, and component repository database.
Many managed kubernetes instances like OpenShift won’t show init containers in their dashboards. So if you’re troubleshooting you may need to look deeper. When fetching logs for an init container using kubectl you must pass the container name as an argument to the call. For example,
kubectl logs <pod> -c <container> -n <namespace> kubectl logs quickstart-kc-db-preparation-job-ddbdbddb-a -c quickstart-kc-db-schema-creation-job -n sprint1-rc
It is unlikely that the init containers will be customized as part of an Entando project. The init containers will automatically restore a backup included in your application so that you can create custom images that include your application setup. See Backing Up and Restoring Your Environment.
The entando-de-app is a J2EE application and is an instance of the entando-core (see a description of the entando-core repo below). Reviewing the dependencies of this application in the pom.xml will reveal the dependencies on the entando-core, entando-engine, and admin-console which encompass the core functionality in versions of Entando prior to Entando 6. In a quickstart deployment the entando-de-app is deployed as part of the entando-composite-app multi container pod.
- GitHub: https://github.com/entando-k8s/entando-de-app/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-de-app-eap (opens new window),https://hub.docker.com/repository/docker/entando/entando-de-app-wildfly (opens new window)
The entando-de-app is very likely to be customized as part of an Entando implementation. This image can be customized with new APIs, legacy Entando plugins, new database tables, or other extensions to the entando-core. It is highly recommended that most extensions to the platform in Entando 6 occur in microservices. However, legacy integrations, extensions to the CMS, and migrations from earlier Entando versions may require changes to the entando-de-app.
The app-builder is the front end of the entando-de-app. It communicates with the entando-de-app via REST APIs. The app-builder is a React JS application and is served via node in the default deployment. In a quickstart deployment the app-builder container is deployed in the entando-composite-app multiple container pod. The app-builder also communicates with the Component Manager via REST API to fetch information about Entando bundles deployed to the Entando Component Repository (ECR).
- GitHub: https://github.com/entando/app-builder/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/app-builder/ (opens new window)
The app-builder is built to be customized and will be customized as part of many Entando implementations. The app-builder can be customized at runtime via micro frontends widget configuration. The app-builder can also be customized via the integration of custom modules that are added at build time.
The component-manager provides the link between the entando-de-app (or your custom core instance) and the Entando Component Repository (ECR). The component-manager queries the entando-k8s service to fetch available bundles that have been deployed as custom resources inside of an Entando cluster. The component-manager also manages the relationships between an Entando application and the installed plugins. This can be seen in the plugin link custom resources in Kubernetes.
- GitHub: https://github.com/entando-k8s/entando-component-manager/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-component-manager/ (opens new window)
It is unlikely that the component-manager will be customized as part of an Entando implementation.
The entando-k8s-service acts as an abstraction layer to fetch data from kubernetes APIs. The primary functionality is in discovering and making available for installation Entando plugins. The entando-k8s-service is invoked by the component-manager.
- GitHub: https://github.com/entando-k8s/entando-k8s-service/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-k8s-service/ (opens new window)
It is very unlikely that the entando-k8s-service will be customized as part of an Entando implementation.
The entando-keycloak project is an extension of the base Keycloak images. The extension provides the default themes for Entando, a customized realm and clients, and adds the Oracle ojdbc jars for connection to Oracle databases.
- GitHub: https://github.com/entando/entando-keycloak/ (opens new window)
- DockerHub: https://hub.docker.com/repository/docker/entando/entando-keycloak/ (opens new window)
The keycloak image will often be customized as part of an Entando implementation. Common extensions will include changing the theme, adding default connections, adding default social logins, adding default clients, or other changes.
# Other Key Repositories
- GitHub: https://github.com/entando/entando-core/ (opens new window)
- DockerHub: None (deployed to maven central)
For users familiar with versions prior to Entando 6 there will be cases where the entando-core is customized. In most cases these customizations will be delivered via WAR overlay in the instance project. Using WAR overlay is a functional approach for users already familiar with the process but it is highly recommended to extend the platform using microservices for new projects.
The entando-cms project is the app-builder (React JS) side of the Entando WCMS. It is bundled into the app-builder at build time and will be included in the default deployment of the app-builder in almost all cases.
- GitHub: https://github.com/entando/entando-cms/ (opens new window)
- DockerHub: None (deployed to npm)
In some cases the entando-cms may be customized if new custom features are added to CMS specific functionality. However, most cases will use the more general app-builder extension points noted above. The entando-cms does not expose any dedicated extension interfaces outside of those already provided by the app-builder.
The entando-components project is a collection of legacy plugins for Entando 5 and earlier. These plugins are deployed as WAR dependencies in an entando-core instance.
- GitHub: https://github.com/entando/entando-components/ (opens new window)
- DockerHub: None (deployed to maven central)
# Entando Kubernetes Controllers
There are a number of controllers that are available to the Entando operator to manage installations and components in an Entando Cluster. Those controllers are small and lightweight images that are executed as run to completion pods to manage the installation flow for different parts of the infrastructure. The controllers are implemented using Quarkus. For more information on the controllers, the Entando custom resources, and configuring your Entando deployment see also: Custom Resources.
- https://github.com/entando-k8s/entando-k8s-composite-app-controller/ (opens new window)
- https://github.com/entando-k8s/entando-k8s-plugin-controller/ (opens new window)
- https://github.com/entando-k8s/entando-k8s-cluster-infrastructure-controller/ (opens new window)
- https://github.com/entando-k8s/entando-k8s-app-controller/ (opens new window)
- https://github.com/entando-k8s/entando-k8s-app-plugin-link-controller/ (opens new window)
- https://hub.docker.com/repository/docker/entando/entando-k8s-composite-app-controller/ (opens new window)
- https://hub.docker.com/repository/docker/entando/entando-k8s-plugin-controller/ (opens new window)
- https://hub.docker.com/repository/docker/entando/entando-k8s-cluster-infrastructure-controller/ (opens new window)
- https://hub.docker.com/repository/docker/entando/entando-k8s-app-controller/ (opens new window)
- https://hub.docker.com/repository/docker/entando/entando-k8s-app-plugin-link-controller/ (opens new window)
It is unlikely that the controllers will be customized as part of an Entando implementation.