ACC provides a foundational software layer and application run-time environment that abstracts away the complexities of building and delivering modern cloud applications. ACC enables organizations to capitalize on them by leveraging their existing skillsets and investments, while also providing them with the catalyst to achieve greater returns on new ones.
At its core, ACC stitches together any number of Windows and Linux resources into a single fabric, turning those resources into a self-service, policy driven application platform (PaaS). With ACC, modern software development and delivery becomes frictionless and IT delivers more value to the business by operating like a world-class service provider.
As a hosting layer, ACC manages network resources while providing an environment that allows your application to function as a service offering even if it wasn’t written as one. Furthermore, very much like your operating system might provide you a control panel, ACC provides a variety of tools via the web to interact with your deployed application.
Conceptually, ACC parallels the operating system or the modern day application server; it defines a concrete layer that “sits below” your application and acts as a host for your application.
ACC focuses on providing value in a few ways:
- Making developers more productive by removing the need to deal with application management tasks
- Making developers more productive by giving them a new but backwards compatible runtime, APIs and frameworks to build composite cloud applications
- Helping organizations increase value by providing a platform for modernizing most of their application portfolio to cloud with little or no effort
- Helping organizations achieve higher efficiency by improving utilization of infrastructure, improving utilization of server licenses, and automating complex application and IT management tasks
Allowing IT to offer self-service application management and deployment to different development teams in the organization
Platform as a service tenants
Multi-tier SOA style applications can be difficult to manage at scale. Services typically need to express their capabilities in a way that dependent clients can discover, ensuring that at runtime, clients can properly locate a service instance to handle its needs. Furthermore, as an application evolves across versions, ensuring consistent version matching of client requests can become difficult.
ACC automatically detects service boundaries and dependencies that are part of your application. SOAP and REST services are automatically versioned and registered within the ACC registry. ACC’s service broker, ensures that runtime client requests are resolved dynamically, and calls are orchestrated to target the appropriate service. Tightly integrated with ACC’s load distribution and HA subsystem, if service instances matching the client requests are not available, ACC will automatically deploy instances to ensure availability.
- Detection of SOAP and REST dependencies
- Automatic late binding of requests to service targets
- Version aware call orchestration that respects non-production vs. production boundaries
ACC’s ability to automatically resolve services and orchestrate calls takes all of the work out of building scalable, dynamic SOA-style applications.
API Based Transaction Metering
ACC’s metering APIs allow developers to define transaction counters, block quantity counters, feature toggles, and feature thresholds to control application logic. This means that end user access to application functionality can be metered and controlled. ACC’s associated product management portal ensures that these API calls can be configured via meta-data as components of entitlement sets.
Application requirements frequently call for “access tiers” that grant different end users different feature sets. In addition, end user usage of application functionality needs to be tracked and potentially limited based on role or need. For example, power users in a particular application having the right to generate unlimited custom reports, with non-power users being limited to a single report per month.
Weaving this sort of control into an application would require that the application track transactions, provide a configurable means for control metered quantities, tracking metered usage, and reconciling usage for allocation on a periodic basis.Developers mark-up source code with API calls, and meta-data defines what an end user is entitled to in that application. At runtime, ACC evaluates entitlements against API calls to determine what an end user is and is not allowed
- Metering and tracking of transactional-style “countable” quantities
- Support for “on/off” feature toggles that block or grant access to functionality
- Entitlement definitions tied to API calls
- Declarative and imperative APIs for flexible, low impact modifications to source code
ACC’s out of the box metering APIs equip developers to flexibly tackle these use-cases with little to no effort. Developers can now achieve configurable, meterable end user usage management and tracking without having to build it.
ACC provides a distributed cache out of the box that automatically distributes work across multiple servers in a way optimized for the PaaS, while providing developers a seamless logical view of that cache through an easy to use API.
Storing state in cloud-architected applications is an important architectural consideration. Cloud-architected applications typically require that no state is saved in standard memory since it state would jeopardize an applications ability to be elastic and scalable. That doesn’t mean that developers are left with no option. ACC provides a platform native distributed cache that allows developers to store state and data in a way that is accessible by the application regardless of where it is running on the platform managed server fabric. This ensures that applications can store and retrieve state, allowing for data to be persisted while avoiding the cloud architecture pitfall of storing state in application memory.
- Optimized for small and medium data payloads
- Expiration-based cache eviction
- Cache scoping for user, tenant, application, and platform cache context
ACC’s out of the box distributed cache provides an easy to use way for developers to tackle the challenges of writing cloud-architected applications.
Federated Authentication with Enterprise Systems
ACC is built to seamlessly integrate with off the shelf or home grown enterprise identity, directory services, and authentication systems. This allows for seamless mapping of end users to guest applications hosted on your internal ACC PaaS instance.
Enterprise identity management, directory services, and authentication systems are well established pillars of most enterprise IT environments. Cataloging the identity and credentials of tens or even hundreds of thousands of users is the norm. Ensuring that your private PaaS can leverage your existing identity management and authentication systems is critical. This guarantees that your applications running on ACC can automatically be federated against your identity systems for authentication and authorization requests.
- Support for SAML and Simple Web Tokens (SWT)
- Leverage home grown identity and authentication systems
- Use out of the box, enterprise focused identity management and SSO systems such as Ping Identity and CA SiteMinder
- Insulate applications from implementation details of SSO and authentication
- Button-click binding of authentication to UIs and web-service APIs. Applications written without authentication can just have it “turned on”
Being able to have a “plug and play” model for integrating your identity and SSO systems with the ACC PaaS is critical for a successful private cloud deployment.
ACC’s on-platform multi-tenant queue support ensures that enterprise developers can leverage asynchronous messaging patterns via their favorite queues as first-class citizens of PaaS.
Modern applications rarely run on a single server, and typically, encounter very demanding scale requirements. These fundamental pressures make asynchronous messaging an important part of developing distributed, cloud-architected applications, and web-scale applications. ACC allows platform operators to configure a system wide queue implementation, and developers to use asynchronous message patterns through a common abstraction layer that is backed by industry standard queue implementations. Additionally, on-platform queues are enhanced for multi-tenant applications, making it trivial to deal with multi-tenancy when using asynchronous call patterns.
- Platform operator configurable queuing ensures standardization of queue usage across development teams in your organization
- API based usage provides for a low friction consumption experience
- Multi-tenancy support ensures that messages are enhanced with contextual information when building multi-tenant applications
- Out of the box support for MSMQ, ActiveMQ, Tibco, and Stomp
- Extensible to allow for the use of additional queue implementations such as RabbitMQ
Leveraging ACC’s on-platform queue implementation ensures that developers get low barrier access to important cloud patterns required by today’s most demanding enterprise applications.
ACC’s application platform makes sharing services across your enterprise simple, fast and secure. By enabling the creation of a centralized repository and listing of available services, developers across your organization can leverage one another’s work to improve time to market of applications.
One of the benefits of ACC’s PaaS is the ability to share applications and services across your organization. ACC enables platform administrators to curate services in a centralized service catalog. IT can set up usage policies and controls while developers get a friction-free way to access common enterprise services and capabilities.
- Securely publish shared services and capabilities across development teams
- Scope visibility and access to services to specific development teams
- Set quotas and consumption control limits
- Self-service ability for developers to discover, provision and de-provision services
As you build your own portfolio of developer services to augment ACC’s built-in catalog, application development transforms into an assembly operation. That means faster time to market and fewer lines of code to maintain for your organization.
End User Onboarding/Provisioning
ACC provides a powerful self-service provisioning system, that can be tightly integrated with your enterprise directory/authentication services.
Applications running on your ACC private PaaS are instantly integrated into a powerful provisioning system for end user on-boarding. The ACC provisioning system allows new end users to supply information at sign up, which is then used to allocate resources, deploy necessary application components, and grant them immediate access to applications – essentially giving you the ability to “turn on” service for customers with no coding on your part. This allows for low-touch, low cost end user on-boarding, keeping your business agile and removing any hurdles that might discourage new end users. Whether you plan on offering self provisioning to your enterprise business end users (or external customer end users), plan on provisioning business end users on their behalf, or a mixture of both, ACC can help!
- ACC’s powerful and flexible provisioning systems allows for instant customer on-boarding.
- Linked directly with ACC’s metering capabilities and APIs, customers can be provisioned automatically with the specific feature set and options they choose.
- Provisioning can still happen in a non self serve fashion as desired.
Building enterprise applications is one thing, getting business end users onboarded is another. As development teams deploy apps and end users want to use them, the lack of a fluid and automated process for provisioning those end users will become a huge stumbling block to growth, introduce human error due to manual intervention, and add unnecessarily to enterprise IT’s overall cost of service.
ACC provides a fully featured Entitlement Engine, allowing developers to flag application functionality an entitlement via API calls. These individual entitlements can be grouped into entitlement sets that instruct the platform on what features to grant to each user, allowing for user-specific application experiences.
Multi-tenancy is an application architecture that allows users grouped into organizational units to access a single shared instance of the application across those organizational units, while giving each user a unique application experience. Some users may need access to specific capabilities in your application that others don’t need, such as a power user needing control over specifics. ACC’s entitlement engine provides an API that makes it easy to specify portions of an applications code that should be considered an entitlement, and that can then be controlled by configuring user specific meta-data to identify what sets of entitlements a given group of users should receive.
- API for denoting standard and meterable transaction entitlements
- Portal based definition of user entitlement sets
- Subscription engine for granting users entitlement sets and managing those entitlements
- Meta-data driven quantity thresholds on metered entitlements
ACC’s Entitlement Engine ensures that developers can map application functionality in a multi-tenant way to users, affording each organizational unit and user an application functional experience tailored to their needs.
App Deployment Policies
ACC application deployment policies enable you to control how applications are matched to your infrastructure within and across clouds.
While ACC enables the enterprise to manage large numbers of servers as a single logical resource, there are often situations where applications need to be mapped to specific infrastructure. In many cases, this is due to security, compliance or resource optimization requirements. ACC application deployment policies enable fine-grained mapping of applications or application components to infrastructure based upon flexible and configurable specific properties.
- Creation of policies with flexible matching logic rules
- Ability to prioritize and sequence processing of large numbers of rules within a policy
- Apply different policies to dev/test versus production
- Create “hard” rules which must be honored alongside “soft” rules which are desired by not required
Instead of created multiple silos with different rules and configurations based upon business needs, ACC application deployment policies enable you to consolidate on shared infrastructure and use a sophisticated deployment policies to honor your specific business requirements.
ACC provides a single platform to run and manage your entire enterprise application portfolio. It ensures that you’ll always know what components your application consists of and where those components are running at all times.
Most enterprises have hundreds of custom applications which change significantly over months and years. It can be challenge to accurately inventory and application portfolio and determine where all of an application’s components currently reside. By centralizing your application platform onto ACC’s private PaaS, real-time application inventory is always available at your fingertips. ACC constantly tracks all applications components across the infrastructure without burdening developers or IT staff with maintaining complicated modeling or discovery tools. This greatly simplifies sharing, support, auditing, maintenance and management of your application portfolio.
- Centralized and searchable real-time application inventory
- Breakdown any application into its individual components and understand how they are connected
- View how any application component is mapped to underlying servers and infrastructure
They key to making smart investments with your enterprise application portfolio is understanding what you currently have. ACC’s private PaaS makes application inventory a feature, not an effort.
Application Lifecycle Management
ACC manages all your web and SOA application deployments through a versioning process, giving you an easy to use patching engine to apply patches for small upgrades and bug fixes or even supply entire replacement releases. You can issue updates to your application as often as you would like and have the peace of mind knowing that ACC has coordinated patching your application across all network resources, regardless of whether your app components are all co-located on a single machine or distributed across multiple servers on the ACC PaaS. Application release management becomes as easy as clicking a few buttons, and deciding when to deploy.
Sophisticated application deployment policies can also be defined for fine grained control over where application components are placed in your environment. Examples include policy to ensure that specific application components are placed on the most performant hardware, deployed only to a specific public cloud infrastructure node, etc.
- Upload patches through ACC’s patching engine or entire new application images all through web based interfaces.
- Role based security over application lifecycle events, ensuring that only authorized team members gain access.
- Parallel versions in the testing sandbox with button click production stage upgrades.
- Integrate with existing build systems and continuous integration through ACC’s API.
Successful application projects are not “deploy once and forget” applications. As an IT organization, you will more than likely upgrade and change your application on a regular basis to provide your end users with new value, keeping you ahead of the competition. If every time you want or NEED to update your application, you have a 30 step manual process, how do you think that will scale over time? Poor application lifecycle management processes are not only costly, but they can cause your business to grind to a halt when your end users lose faith in you because of poor quality control and application downtime.
Well defined application lifecycle management processes, supported by sophisticated systems for managing the complexities of patching and updating your live application is key to remaining agile, and having the capability to respond to your customers and market instantly.
Self Service Dev Portal
ACC’s self-service developer portal provides enterprise development teams with a friction free experience for managing applications throughout their lifecycle.
The ACC developer portal is designed to simplify sophisticated application lifecycle operations such as creation, deployment, scaling, patching and versioning.
Tasks which previously took hours, days or weeks are reduced to seconds. Developers focus on their code and applications while ACC’s platform abstracts away infrastructure details like servers, load balancers and storage. The developer portal can also be used by teams of developers who are working together across one or more applications.
- Intuitive and easy to use GUI for common application workflows
- Role based access control for scoping operations within or across teams of developers
- Consolidated view of all applications, application components along with their performance and resource consumption
- IDE pluggins, command line and REST based interfaces for further automating operations
ACC’s self-service developer portal enables enterprise application developers to quickly and securely deploy and manage applications.
Self Service IT Portal
ACC provides central IT with a single pane of glass to view and manage resources, settings and policies associated with your enterprise PaaS
ACC enables IT pros to manage large numbers of servers as a single, contiguous resource pool. Using ACC’s self-service portal, IT can define settings and policies including security, resource consumption and auditing. IT also gets a consolidated view of infrastructure utilization to help ensure timely provisioning of new capacity based on real-time consumption of the current capacity.
- Single pane of glass for managing infrastructure utilization across the PaaS deployment
- Centralized management of security and resource policies
- Global view of applications througout the infrastructure including the ability to migrate applications between servers
- Consolidated view of application logs across the PaaS
ACC’s self-service IT portal enables centralized, efficient and secure operation of the platform enterprise wide.
ACC’s Logging System allows developers to log messages easily and efficiently, even on a distributed network of servers. Complete with log levels, filtering, and notifications, the Logging System provides an out of the box way to handle most application logging needs.
Standard single server applications typically log data to a text file on disk. Finding and digesting log information is trivial, making standard logging systems satisfactory. PaaS’ typically run on a distributed network of servers that make logging even the most basic data difficult since log files could appear anywhere on the network of servers supporting the PaaS.
- Logging API that can be used directly or wrapped as an appender and used through other logging APIs
- Configurable log levels for developers with scoped log level filters controlled platform wide by operators and on a per application basis by developers
- Global, cross application and cross development team searching of log data for platform operators
- Cross application searching of log data for development teams
- Configurable platform wide and application wide log level thresholds
- Log masking to “find and replace” sensitive data patterns in developer posted logs, increasing compliance with corporate data policies
- Email notifications based on application and log level
- Contextual tagging for multi-tenant applications
The ACC Logging System centralizes log messages, making them auditable and searchable from anywhere.
ACC’s resource allocation tracking provides the foundation for translating platform hosted workloads to chargeback/showback events to the lines of business leveraging the PaaS environment.
Enterprises are shifting to a new reality where their IT departments are behaving more like service providers. Rather than committing resources to a specific line of business, IT is moving to an internal utility model. To support this, ACC tracks resource allocations for each application and exposes that data to IT via an API. IT can then communicate that information to developers for chargeback/showback purposes.
- Tracking of application counts, error rates, CPU, memory and storage
- Platform level and developer team level reporting scopes
- ACC Platform Allocation Reporting API (SOAP & REST)
- Cost definition mapping from resource policies to roll-up chargeback/showback costs
Additionally, resource allocation and utilization tracking on the ACC platform is designed to give Platform Administrators the real-time knowledge they need to make informed capacity-planning decisions. Likewise, the same metrics as seen through the lens of a developer team enables developers to track and make better use of the resources they consume. In the end, the data offered by the ACC platform allows the Platform Administrator and the Developer groups to jointly maximize efficient use of the platform infrastructure, both from a resource and cost perspective.
System Centre Integration
ACC enables System Center customers to seamlessly integrate their Microsoft IaaS and Monitoring solution with ACC’s application platform.
ACC provides a self-service IT operations portal for centralized management of the PaaS platform. Customers who want to manage ACC from their System Center monitoring console can do so with ACC’s built-in management pack (MP). ACC’s System Center MP enables customers to get rich and deep monitoring, alerts and diagram views of their ACC infrastructure, applications and users. Customer’s can also use System Center’s Virtual Machine Manager to provision servers (physical and virtual) to be automatically added to the ACC resource pool based on configurable utilization thresholds.
- Centralized and deep health monitoring of all ACC components and dependencies via System Center
- Alerts for capacity thresholds and configuration errors along with troubleshooting diagnostics and knowledge
- Ability to tie System Center Orchestrator automation with ACC alerts to automatically remediate issues as they arise
- Use System Center Virtual Machine Manager (SCVMM) to provision new physical and virtual machines and expand your ACC resource pool capacity
By integrating directly with System Center, ACC snaps into your existing management tool investments and reduces the cost and complexity of running the platform.
ACC enables you to pool servers across multiple clouds and use policy to determine where you applications land and consume resources.
Most enterprises have multiple environments where they run and manage applications. Typically this includes several geographies along with combinations of private, public or hosted resources. They often further divide each of these “clouds” by use case such as dev/test, staging and production. ACC enables customers to combine resources from across these clouds into a single logical resource pool and apply flexible and powerful application deployment policies. These policies can be used to automatically map applications to infrastructure based on multiple factors including use case, security, compliance, business unit, geography etc.
- Pool resource from multiple clouds into a single logical resource pool
- Define application deployment policies to map applications to clouds
- Single pane of glass to manage resources and applications across hybrid clouds
ACC’s hybrid cloud capabilities provide the flexibility to efficiently map resources across public and private clouds to enterprise application portfolios.
ACC’s custom tagging makes it easy to extend the ACC data model to track information related to applications and infrastructure that is important to you.
Custom tagging enables administrators to add additional properties to call core ACC objects. Sometimes this means tracking business data like cost centers or organization names. Other times it might mean adding technical or SLA information about applications or infrastructure. ACC lets you add this metadata to core objects which can be handy when you’re integrating the platform with existing enterprise systems. ACC application deployment policies can also use these custom properties to automatically select infrastructure most appropriate for the application being deployed or scaled.
- Define or edit tags for core ACC objects
- Define rules for the custom tags including visibility, allowable values, required/optional
- Use the values of custom tags to help select infrastructure for applications and application components
Every enterprise is unique. ACC’s extensible custom tagging capability helps integrate and extend core capabilities of the platform to better fit specific needs.
Load Distribution and HA
Applications running on the ACC PaaS fabric become highly available and able to handle scaled load with no additional coding. ACC’s use of HTTP load balancing and custom SOAP/REST message routing ensure optimized load distribution, while the ACC container guarantees availability.
Today’s applications are expected to be available and scalable. This means that application architectures and the infrastructure they run on need to be equipped to deal with SLA parameters that have world-class uptime and performance demands. Applications need to be built loosely coupled so components can be scaled easily, and load distributed across multiple instances. Monitoring tools and infrastructure need to be able to detect failures and spin-up application components to guarantee not only availability, but performance that is consistent with SLA expectations.
When a standard SOA or web application is deployed to ACC, it automatically inherits these qualities. Application components at all tiers can be scaled across the ACC PaaS fabric, ensuring proper load distribution. Additionally, components are deployed on ACC containers that monitor for failures and can recover automatically.
- Scale-out architecture for gauranteed load distribution at any application tier
- Automatic monitoring of application failures for immediate recovery
- Snapshots of application stack traces on HA events, complete with context for easy diagnosis
- Developer-drive configurable minimum instance counts to define baseline capacity footprint expectations
Time to market and application production quality improvements become easy, without having to add any development or infrastructure effort.
Resource policies give platform operators the ability to use meta-data to publish CPU, memory, and storage plans that developers in the enterprise can associate with their applications. ACC allocates resources based on what developers choose, dividing the infrastructure based on these policies.
The ACC PaaS stitches together any number of Windows and Linux OS instances (physical or virtual) into a single, logical hosting fabric. Rather than relying on virtual machines as a container for providing application isolation, ACC uses a custom container model that runs inside OS instances to isolate applications from one another. This fine-grained isolation is used to sub-divide each OS instance into multiple segments, increasing utilization and reducing hardware and licensing costs. Resource policies are the defining unit that allow platform operators to define how large these segments are from a CPU, memory and storage perspective, and are published to developers as the set of options they may choose from when allocating resources to their applications.
- Process and database level isolation increases infrastructure utilization and slashes licensing costs
- Define quotas for CPU, memory, and storage. Drag and drop and manifest based assignment of quotas for developers.
- Publishing system ensures platform operators can control resource options for developers, while allowing developers the freedom to make application specific resource decisions
- Utilize tier specific definitions (frontend, web-services/daemons, or databases) or publish broad based definitions
- Cost definitions for chargeback/showback
- Oversubscription allows for higher policy packing density
- Hypervisorless implementation allows for bare-metal deployments
- View and manage live application components through resource policy filters
Through resource policies, platform operators in the IT department get ultimate control over resource utilization while giving developers the authority to make sanctioned, application level resource assignment decisions. The end result is lowered IT costs through increased utilization and compliance.
REST API & Command Line Interface
ACC provides developers with a powerful REST API and Command Line Interface named the ACC Cloud Shell (ACS). ACS and the API can be leveraged to customize the Developer experience of deploying and managing guest applications on the ACC Platform.
While the ACC Developer Portal provides a UI for developers that exposes easy application deployment and management, automation and convenience needs require a clean API and command shell that exposes the same functionality.
- Connect and manage multiple ACC instances from ACS
- Build custom UIs using the ACC REST API
- Build ACS based scripts for developer driven automation
- Integrate ACC’s application management workflows with the systems of your choice
ACC’s application management API and command shell provide the foundation for ultimate developer convenience and flexibility. Developers can manage applications through simple single commands, or build custom UIs and automation integration to help blend ACC into an enterprises standard development environment.
Extensible Cloud Application Services
ACC’s powerful out of the box capabilities are flanked by a composable service add-on model. The add-on model affords an ACC PaaS operator the power to plug-in arbitrary components such as NoSQL stores, queues, and other services to the platform. These services can be configured, managed, and exposed to developers for easy consumption by guest applications.
No application platform could ever entertain the idea of providing every possible capability needed by developers. A proper platform allows one to extend the platforms capabilities with custom and 3rd party services that can then be easily brokered to developers and the guest applications that they write.
ACC’s add-on model makes it a trivial task to extend the platform with additional services and capabilities. Developers can pick and choose from available services and bind their applications to those services. ACC automatically provisions resources from the add-on when needed, tying the resource and access to that resource to the lifecycle of the developer’s application.
- Add-on installation and management controlled centrally by ACC operators
- Developer service add-on catalog makes discovery and use easy
- Associated API trivializes access management for guest applications
Ensuring extensibility as a first class citizen provides developers with a guarantee that their component and services needs will always be satisfied.
Custom Workflow Extensions
With custom workflow extensions, enterprises can tailor ACC operations to fit their unique requirements.
ACC dramatically simplifies nearly every aspect of application management. With that said, every enterprise is unique and requires their own specific customization to ensure this platform benefit is fully realized. Workflow extensions enable platform operators to run arbitrary business logic at nearly every important “event” in the application’s lifecycle. This allows customers to integrate ACC seamlessly with existing business processes and IT systems.
- Extensive set of event “hooks” where custom workflow can be integrated
- Easy to write and test extensions which run natively on the ACC platform
- Multi-tenant awareness of extensions to selectively execute operations
One of the key benefits of ACC’s private PaaS is the ability to customize it to fit your needs. Custom workflow extensions are just one way to integrate ACC seamlessly into your operations.
ACC provides two tiers of multi-tenancy. First, ACC itself is multi-tenant, essentially providing platform/infrastructure multi-tenancy. This means that ACC aggregates all your infrastructure into a single unified resource pool, and allows deployed applications to share those resources in a highly efficient way. No more dedicating entire servers or VMs to single applications: let ACC deal with details of sharing application and database servers between applications. This new level of efficiency layered on top of your existing infrastructure investments will significantly drive down cost of application delivery, while providing incredible agility.
Second, ACC provides standard single-tenant web and SOA guest applications – the apps your enterprise IT developers build – with true application level single instance, multi-tenancy at all tiers. Single instance multi-tenancy is a software architecture principal where your application components such as your database, web services, and user interfaces are shared across many customers rather than each customer having their own copy. This complex architecture popularized by the worlds best SaaS providers can now be used to drive down cost of delivery even further for a variety of enterprise application use cases. Single instance, multi-tenancy is one of the most important architectural qualities of modern day cloud applications; it ensures a high level resource utilization without sacrificing quality, giving your development teams the ability to deliver applications with extreme cost effectiveness. However, single instance multi-tenancy is also one of the most difficult, time consuming, and expensive parts of a modern cloud architecture to engineer and maintain. Since ACC productizes this architecture pattern as an inheritable feature, guest applications can leverage it as a standard platform service, thereby skipping over the long and expensive development cycle.
How does it work?
ACC’s zero effort application level single instance, multi-tenancy isolates end users by handling data partitioning, request routing, and authorization security at the application server layer – even though end users are sharing resources. Moreover, ACC gives you the ability to define certain aspects of your application’s multi-tenant behavior, such as whether data from multiple customers can be mixed in database deployments or separated into dedicated databases. This powerful concept of configurable “drop-in” single instance, multi-tenant capability provides a massive time-to-market boost and takes a major maintenance and security pain-point off your plate.
- Zero-effort single instance multi-tenancy enables a single instance of your application to serve thousands of tenants (external customers, partners, internal business units, branches, franchises, etc.)
- Multi-tenant data model strategies and other significant design time considerations become flexible deploy time configuration options with ACC.
- Choose from a single commingled database, a database schema per customer, or an isolated database per tenant.
When writing an application to deploy on ACC, developers need not worry about multi-tenancy. ACC applications are written just like a regular on-premises applications in that it targets single customer deployment with no notion of multi-tenancy in the source code, database, or user interfaces. However, once that application is deployed to an instance of ACC and is running live, ACC automatically endows the application with a single instance, multi-tenant architecture.