In the previous parts of this series, we explored how Bacula Community and Bacularis can provide a free and open-source foundation for managed backup services, and how service providers can use them to manage customer backups and offer controlled self-service access.
The next step is designing the infrastructure that will support these services.
Managed service providers have different requirements. Some operate centralized backup environments serving multiple customers, while others manage separate backup installations at customer locations or across multiple data centers.
Bacula Community provides a flexible network-based architecture, while Bacularis offers web-based management capabilities and integration interfaces that can be adapted to different deployment models.
In this article, we will explore several approaches to organizing backup infrastructure for MSPs, including customer separation, network security, integration with existing services, and deployment standardization.
The examples are intended to illustrate architectural possibilities rather than provide ready-to-use production configurations. Each service provider should design and validate its infrastructure according to its customers' requirements, security policies, and operational capabilities.
One of the first architectural decisions an MSP needs to make is how to organize backup environments for its customers.
Bacula Community and Bacularis support different approaches, from shared backup infrastructures to independent customer environments and geographically distributed installations.
The following examples illustrate three deployment models that service providers can consider.
In a shared backup environment, multiple MSP customers use the same Bacula infrastructure.
For example, one Bacula Director can manage backup Jobs and Clients belonging to Customer A, Customer B, and Customer C.
The MSP maintains the shared infrastructure, including the Director, Catalog, Storage Daemons, backup policies, and associated storage resources.
Bacularis provides a common web interface for managing these resources.
If customer self-service is offered, administrators can configure individual Bacularis accounts, restricted API host connections, and Bacula Console ACLs to limit access to the appropriate resources and operations.
Potential advantages of this approach include:
Centralized administration of backup resources.
Sharing infrastructure components between customers.
Fewer independent Bacula environments to maintain.
Flexibility in organizing customer-specific Jobs, Pools, and storage policies.
However, sharing infrastructure also introduces important security and operational considerations.
Customer access restrictions must be carefully configured and tested. Shared infrastructure components may also create dependencies between customers, meaning that a failure or maintenance operation affecting a common component can impact multiple services.
A shared environment therefore requires particular attention to access control, resource planning, monitoring, and operational procedures.

Another approach is to maintain independent Bacula environments for individual customers or groups of customers.
For example, Customer A and Customer B may each have their own Bacula Director, Catalog, backup configuration, and storage infrastructure.
These environments can be located in the MSP's data centers, on customer premises, or in other locations selected by the service provider.
Bacularis supports this model through its separation of the Web interface and API services.
One Bacularis Web interface can connect to multiple Bacularis API hosts, allowing administrators to access and manage different Bacula environments without maintaining a separate web interface for every installation.
Potential advantages of this approach include:
Greater independence between customer backup environments.
More flexibility in applying customer-specific configurations.
The possibility of maintaining separate administrative and operational boundaries.
Reduced dependencies between customers when the underlying infrastructure is also appropriately separated.
The main consideration is the increased number of components that need to be installed, configured, updated, monitored, and maintained.
Separate Bacula installations do not automatically provide complete customer isolation if they still share storage, credentials, administrative systems, or other infrastructure resources.
The actual level of separation depends on the complete architecture and its security configuration.

Bacula Community is a network-based backup system. Its components do not need to operate in the same physical location.
A Bacula Director can manage File Daemons and Storage Daemons located on different servers and across different networks or geographical locations.
For example, an MSP may operate a central Bacula Director while protecting customer systems in several cities or countries.
Depending on the chosen architecture, Bacula File Daemons can send backup data to Storage Daemons located at customer sites, in the MSP's data centers, or at other selected locations.
Bacularis can be used to manage such an environment through its Web interface and appropriately configured API hosts.
Distributed architectures may be useful for:
Protecting systems located at multiple customer sites.
Managing backups across different data centers.
Placing Storage Daemons in the same local network as protected systems to reduce backup traffic over WAN connections.
Supporting off-site backup copies and disaster recovery strategies.
Operating backup infrastructure across different geographical regions.
The MSP must account for network connectivity, bandwidth, latency, security, storage availability, and the operational requirements of the selected locations.
The network paths used for backup data, restore operations, and administrative communication should be considered separately when designing the infrastructure.

These deployment models are not mutually exclusive.
For example, an MSP can maintain separate Bacula environments for different customers while distributing the File Daemons and Storage Daemons of each environment across several locations.
Another MSP may operate a shared Bacula Director while using different storage locations and backup policies for individual customers.
The choice depends on factors such as customer requirements, security, infrastructure costs, administrative complexity, recovery objectives, and the level of independence required between environments.
There is no single deployment model suitable for every managed backup service.
Bacula Community provides the underlying backup capabilities, while Bacularis helps administrators manage the resulting environments through a common web interface.
The MSP remains responsible for selecting, designing, securing, and maintaining the architecture that best fits its services.
When designing backup services for multiple customers, MSPs need to consider how customer resources, administrative access, and backup infrastructure should be separated.
The appropriate approach depends on the deployment model, customer security requirements, and the level of independence expected between backup environments.
Bacula Community and Bacularis provide mechanisms that can support different approaches to customer separation.
In a shared Bacula environment, backup resources belonging to different customers are managed by the same Bacula Director.
For example, Customer A and Customer B may have separate Clients, Jobs, FileSets, Pools, and retention policies while using shared infrastructure components.
Bacula Console Access Control Lists (ACLs) can restrict access to selected resources and operations.
Bacularis complements these mechanisms with role-based access control, individual API host configurations, and API function permissions.
Together, these capabilities allow MSPs to provide customers with access to selected backup resources without granting unrestricted administrative access.
However, sharing a Bacula Director and other infrastructure components also means sharing some underlying operational and security dependencies.
Access restrictions do not provide the same level of separation as completely independent environments. A shared Director, Catalog, or storage infrastructure may still represent a common point of failure or administrative responsibility.
For this reason, MSPs should carefully evaluate whether resource-level access restrictions are sufficient for their customers' requirements.
An alternative is to maintain separate Bacula environments for different customers or customer groups.
Each environment may have its own Director, Catalog, backup configuration, and storage resources.
This approach can provide stronger administrative and operational boundaries, particularly when the underlying systems and storage infrastructure are also separated.
For example, an MSP may maintain independent Bacula installations for customers with specific security policies or infrastructure requirements.
Bacularis Web can connect to these environments through their respective Bacularis API hosts, allowing authorized administrators to manage them from a common interface.
However, independent Bacula installations do not automatically guarantee complete isolation.
Shared administrative accounts, storage systems, network services, or other infrastructure components can still introduce dependencies between environments.
The MSP must evaluate the complete architecture rather than relying only on the number of Bacula Directors.
Customer separation also requires appropriate access control in the management interface.
For example, an MSP administrator may need access to all managed backup environments, while a customer should only be able to access the environment and operations assigned to them.
Bacularis allows administrators to assign API hosts to users and configure access to selected functions and resources.
In shared environments, Bacula Console ACLs provide additional restrictions on the resources available through the corresponding API connections.
These mechanisms should be configured together according to the responsibilities of individual users.
As discussed in the second article, Bacularis Web roles control access to interface pages, while API access restrictions and Bacula Console ACLs control other aspects of the available operations and resources.
Regardless of the chosen architecture, MSPs should test their access restrictions before making backup services available to customers.
Testing should confirm that authorized users can perform their permitted operations and cannot access resources or functions outside their assigned permissions.
For example, a customer account should not be able to browse backup information belonging to another customer, perform unauthorized restore operations, or modify administrative settings.
Access restrictions should also be reviewed when customers, protected systems, API hosts, or user responsibilities change.
The chosen separation model and its security configuration remain the responsibility of the service provider.
For more information about configuring restricted access, please refer to the Bacularis restricted access documentation.
When backup infrastructure is distributed across customer locations, MSP data centers, and other environments, network design becomes an important part of service reliability and security.
Bacula Community uses network communication between its components, while Bacularis provides web-based administration through its Web and API interfaces.
MSPs need to consider how these components communicate, which connections should be permitted, and how access to the infrastructure should be protected.
It is important to distinguish between management communication and backup data transfer.
Bacularis Web communicates with Bacularis API over HTTP(S). Bacularis API provides access to Bacula management operations and other functions available through its API endpoints.
The Bacula Director coordinates backup and restore operations and communicates with the appropriate Bacula components.
During regular file backup operations, backup data is transferred between the Bacula File Daemon and Storage Daemon.
This separation allows MSPs to design their management infrastructure independently from the network paths used for transferring backup data.
For example, a central Bacularis Web interface can manage backup environments located at different customer sites, while backup data is transferred between the Bacula components according to their configuration.
Distributed backup environments require reliable communication between the components involved in backup and restore operations.
MSPs should consider network connectivity, available bandwidth, latency, and the expected volume of backup data.
Firewalls, VPNs, routing configurations, and other network controls may be used to limit communication to the required systems and services.
For example, a customer site may provide access to its Bacula File Daemons only through a protected network connection established for backup operations.
Similarly, Bacularis API endpoints and Bacula administrative services should not be exposed to untrusted networks unnecessarily.
The required connectivity depends on the chosen architecture and the locations of the individual components.
Security is particularly important when backup management and data transfer take place across different networks.
Bacularis Web and API communication can be protected using HTTPS.
Bacula Community also supports encrypted communication between its components, including the Director, File Daemon, and Storage Daemon.
Bacula Community supports encrypted communication between its components using TLS PSK, which is enabled by default in modern Bacula versions. Alternatively, the certificate-based TLS can also be configured when required.
MSPs should review their transport security and authentication settings to ensure that communication is protected according to their infrastructure and security requirements.
Transport encryption protects data while it is being transmitted. It should not be confused with encryption of backup data stored on Volumes, which is a separate consideration.
Administrative access should also be protected through suitable authentication methods, carefully assigned permissions, and secure handling of credentials.
In distributed environments, MSPs can choose where backup data is stored according to their service architecture.
For example, backup data may be written to storage at the customer's premises, in an MSP data center, or at another selected location.
These decisions can affect network usage, recovery performance, operational complexity, and the availability of backup data during an infrastructure failure.
Service providers should also consider whether additional backup copies are required at separate locations.
Maintaining additional backup copies in separate locations can help MSPs recover customer data if one location becomes unavailable. However, these copies should be properly managed and regularly tested to ensure that they can be used when needed.
MSPs should evaluate data location, access restrictions, retention requirements, and applicable customer or regulatory obligations when designing their storage infrastructure.
Bacularis provides a central management interface that can access important backup operations and configuration resources.
For this reason, protecting Bacularis Web and API installations should be part of the overall security architecture.
MSPs should maintain appropriate access restrictions, protect administrative credentials, apply relevant security updates, and monitor their management systems.
They should also consider how access is provided to MSP administrators and customer self-service users, particularly when both groups use the same Bacularis Web installation.
The chosen network and security architecture should be tested and reviewed regularly as the managed backup infrastructure evolves.
For detailed configuration guidance, please refer to the Bacularis documentation and the Bacula Community documentation.
Managed service providers often use different tools for customer management, monitoring, authentication, reporting, and other operational activities.
When building backup services, integrating backup management with these existing systems can help reduce repetitive work and provide a more consistent experience for administrators and customers.
Bacularis offers integration capabilities that MSPs can use when developing their own services and operational workflows.

Bacularis provides a REST API that can be used independently of the web interface.
The API offers access to many Bacula management and monitoring operations, allowing service providers to develop their own scripts, applications, and integrations.
For example, an MSP may use the Bacularis API to:
Retrieve backup job results for an existing monitoring system.
Display selected backup information in a customer portal.
Start permitted backup operations from an external application.
Retrieve information about protected systems and backup resources.
Integrate selected administrative operations into existing workflows.
These examples illustrate possible integrations rather than ready-made solutions provided by Bacularis.
For instance, an MSP with its own customer portal could develop a feature that displays recent backup results for an authenticated customer.
In this scenario, the MSP application would communicate with Bacularis API and present the retrieved information according to its own interface and access control requirements.
Bacularis provides the API capabilities, while the MSP remains responsible for developing the integration and ensuring that users can access only the data and operations they are authorized to use.
The available API operations and their permissions depend on the Bacularis API configuration and the underlying Bacula access restrictions.
For endpoint details, please refer to the Bacularis REST API documentation.
MSPs may already maintain user accounts and access policies in centralized identity management systems.
Bacularis supports integration with external authentication services, including LDAP and identity providers using OpenID Connect.
These capabilities can help service providers use their existing identity infrastructure for accessing the Bacularis web interface.
Bacularis also supports user provisioning and role mapping, allowing user accounts and Bacularis roles to be managed in connection with external identity systems.
For example, an MSP using an OpenID Connect identity provider may allow its administrators to authenticate to Bacularis using their existing organizational accounts.
With role mapping, roles or groups defined in the identity provider can be associated with corresponding Bacularis roles.
This can simplify user administration, particularly when multiple administrators or customer users need access to the service.
However, centralized authentication and role mapping do not automatically define access to individual Bacula backup resources.
MSPs must also configure the appropriate API host access, API permissions, and Bacula Console ACLs, as discussed in the previous sections.
The Bacularis API can also become part of broader operational processes maintained by an MSP.
For example, a service provider may develop scripts that periodically retrieve backup results and forward relevant information to an external monitoring or reporting system.
Another MSP may integrate selected backup operations into its internal administration tools, reducing the need for operators to switch between different applications.
Such integrations can support existing service management processes, but their implementation depends on the systems and requirements of the individual MSP.
Bacularis is not a complete MSP business management platform and does not provide every integration that a service provider may need.
Instead, its API and authentication capabilities provide building blocks that MSPs can use to connect Bacula backup management with their existing infrastructure and services.
As an MSP adds new customers and protected systems, maintaining consistent backup configurations becomes increasingly important.
Preparing each host and backup configuration manually may be manageable in a small environment, but it can become time-consuming and more difficult to maintain as the infrastructure grows.
Bacularis provides tools that can help service providers standardize selected deployment and configuration activities.
Bacularis includes a Deployment feature that allows administrators to install and manage Bacularis API and Bacula components on remote hosts.
The deployment process begins with installing and configuring Bacularis API on the target host using SSH.
Once the API is available, administrators can use Bacularis to install, upgrade, or remove supported Bacula components through API operations.
For example, an MSP adding a new Linux server to its managed backup infrastructure may use Deployment to prepare the host and install a Bacula File Daemon.
The feature can also be used when preparing hosts for other supported Bacula components.
Bacularis provides operating system profiles that define installation and configuration procedures for different environments. Administrators can also prepare custom profiles according to their requirements.
The availability and success of deployment operations depend on the target operating system, required software, network connectivity, administrative access, and other dependencies.
MSPs should test their deployment procedures before using them in production environments.
For more information, please refer to the Bacularis Deployment documentation.
Installing Bacula components is only one part of preparing a backup environment.
MSPs also need to define Jobs, Clients, FileSets, Schedules, Pools, and other Bacula configuration resources according to their backup policies.
As discussed in the second article, Bacularis provides Configs and Patterns for creating reusable Bacula configurations.
These mechanisms can help service providers maintain consistent resource structures when adding customers or protecting additional systems.
The following screenshots show Configs and Patterns prepared for the MSP test environment used throughout this article series.
For example, an MSP may prepare reusable Configs for related Bacula resources and use variables for customer-specific information, such as customer names and server names.
Related Configs can be grouped into Patterns, as shown in the following example. A Pattern can then be applied to a Bacula component configuration using values appropriate to each customer.
When applying selected Patterns, Bacularis prompts the administrator for the variables used by their Configs. The administrator can enter customer-specific values, choose an overwrite policy, and run a simulation to review the expected configuration changes before applying them.
This step shows how reusable Patterns become a practical tool for creating customer-specific Bacula configurations.
Configs and Patterns can be used when configuring existing Bacula components and as part of supported deployment workflows.
This helps MSPs standardize selected configuration activities while retaining control over the resulting Bacula configuration.
In environments with multiple Bacula installations, Bacularis Web can connect to different Bacularis API hosts from a common management interface.
As the number of API hosts grows, organizing access to them can become another administrative task.
Bacularis provides API host groups, which allow administrators to organize API hosts into logical collections.
These groups can be assigned to users, making it easier to manage access when several administrators need to work with the same set of hosts.
For example, an MSP may create a group containing API hosts associated with a particular operational team or infrastructure area.
When the group membership changes, administrators can update the group instead of modifying the host assignments of every user individually.
API host groups help organize access to management connections. They do not automatically create customer isolation or replace the access restrictions configured for individual API hosts and Bacula resources.
Deployment tools, Configs and Patterns, and API host groups address different aspects of infrastructure management.
Used together, they can help MSPs introduce greater consistency when expanding their backup environments.
However, standardization does not mean that every customer must use identical backup settings or infrastructure.
Service providers should maintain reusable procedures and configurations while allowing appropriate differences in backup policies, storage requirements, security settings, and recovery objectives.
Bacularis provides tools that support these activities, while MSP administrators remain responsible for designing, validating, and maintaining their deployment and configuration standards.
Building a managed backup service requires more than selecting backup software. Service providers need to design an infrastructure that meets their customers' requirements and can be maintained reliably as their services grow.
Bacula Community and Bacularis provide a flexible foundation for different deployment approaches, but the appropriate architecture depends on the individual MSP and its operational needs.
Before introducing a new backup service, it is useful to consider several important questions.
How should customer backup environments be organized?
Decide whether customers will share a Bacula environment or use separate installations. Consider security requirements, administrative responsibilities, infrastructure resources, and the level of independence required between customers.
Where should backup data be stored?
Plan the location of backup storage, available capacity, retention policies, and additional backup copies. Consider network connectivity, recovery requirements, and the consequences of losing access to a storage location.
How should administrators and customers access the service?
Define which users need administrative access and which operations can be offered through customer self-service. Plan Bacularis Web roles, API host access, Bacula Console ACLs, and appropriate network security controls.
How can deployment and configuration be standardized?
Consider using Bacularis Deployment, Configs and Patterns, and reusable configuration procedures to prepare new environments and protected systems consistently.
How should the backup service integrate with existing tools?
Evaluate whether the MSP needs to connect backup management with customer portals, monitoring systems, identity providers, or other operational tools through Bacularis API and supported authentication mechanisms.
How will the service be maintained and verified?
Define responsibilities for monitoring, updates, storage management, access reviews, and recovery testing. Ensure that the MSP has the technical knowledge and operational procedures needed to maintain the service.
There is no single architecture that fits every managed backup service.
An MSP protecting a small number of customer systems may have different requirements from a provider operating backup infrastructure across multiple data centers and customer locations.
A practical approach is to begin with a clearly defined deployment model, validate the configuration in a test environment, and expand the infrastructure as operational requirements become better understood.
Before introducing a service into production, MSPs should verify backup and restore operations, customer access restrictions, storage management policies, and the availability of the required infrastructure components.
Regular reviews and recovery testing should remain part of the service as it evolves.
Throughout this three-part series, we have explored how Bacula Community and Bacularis can be used together to build and manage independent backup services.
We started with the possibilities offered by free and open-source backup technology, continued with everyday backup management and customer self-service, and finally explored deployment architectures, security, integrations, and configuration standardization.
Bacula Community provides the underlying backup capabilities, while Bacularis offers a web-based management interface and additional tools that can help service providers organize, manage, and extend their backup environments.
The flexibility of these technologies allows MSPs to choose their own infrastructure, operating procedures, and service models without requiring a predefined backup service architecture.
Ultimately, successful managed backup services depend not only on the software being used, but also on careful planning, experienced administration, and reliable operational practices.
We hope this series provides a useful starting point for MSPs exploring how Bacula Community and Bacularis can support their own backup services.