Common Cloud Core (C3) Multi-Hybrid Cloud¶
Common Cloud Core (C3) Overview¶
The Common Cloud Core is a reference architecture that targets IT and Software Developers that want to develop, test and deploy application ina Multi-Hybrid Cloud system. This reference architecture shows the use cases, and specs for implementing the CCC Architecture. The architecture is broken up into several different components and sections. An introductory video that gives a brief overview of Common Cloud Core.
High Level Use Cases¶
- Manage Applications
- Manage Application Stack
- Manage Clouds
- Manage Environments
- Manage Infrastructure
- Manage Policies
- Manage Service
- Manage Service Template
- Manage Stack Template
- Manage Users
High Level Concepts¶
- Application Stack - contains a reference to services that are required to make an Application. There can be different configurations based on Environments
- Service - represents a service running in different environments. Example: A MongoDB service could be a simple instance or a HA solution based on the environment it is running in.
- Composite Service - represents an aggregation of services that are managed together. There can be multiple configurations of composite services basd on environments.
- Script - a script that is run based on events that are happening in the System. Examples. Start, Stop, Deploy, upgrade.
- Image - a standard image that can be deployed to any number of clouds or environments.
- Environment - A group of resources with policy that applications and services execute. Each Environment has unique policies that govern the services and applications in the environment.
Environments and Applications¶
Service Stacks and Services can have a definition for individual environments. This allows Developer to deploy applications to multiple environments. In this example a simple NodeJS Application Stack can be deployed into four different environments with different service topologies. Please look at Example for more [detailed examples](Examples) of a NodeJS application running in multiple Environments.
Local Environment¶
Only 3 containers or VMs are running this application in a VirtualBox on the local machine.
Development Environment¶
Now the Application is running in the Cloud and we have introduced a Working Node to handle some additional load and allow for scalability testing.
Test Environment¶
Now the developer wants to test his code on an environment that has more debugging tools and enough services to show the scalability and cloud awareness of his application.
Production Environment¶
Production Environment with High Availability Services to make sure we have QoS required by SLAs that have been agreed to. Additional Services have been added and multiple instances of primary services are running.
High Level Architecture¶
The C3 Architecture contains several subsystems and components. The following is a diagram on how these components work together to fulfill the high level use cases.
Implementations¶
The C3 architecture is the integration of several tools that fulfill the use cases and features of the architecture. The following are different implementations of the conceptual architecture.
Generic Solution Overview¶
The Common Cloud Core is a reference architecture that targets IT and Software Developers that want to develop, test and deploy application ina Multi-Hybrid Cloud system. This reference architecture shows the use cases, and specs for implementing the CCC Architecture. The architecture is broken up into several different components and sections. An introductory video that gives a brief overview of Common Cloud Core.
Use Cases¶
- Manage Applications
- Manage Application Stack
- Manage Clouds
- Manage Environments
- Manage Infrastructure
- Manage Policies
- Manage Service
- Manage Service Template
- Manage Stack Template
- Manage Users
Logical Architecture¶
The C3 Architecture contains several subsystems and components. The following is a diagram on how these components work together to fulfill the high level use cases.
- Application Analyzer - Deep learning analytics for application optimization
- Application Manager - Manage Applications (Creation, Launch, Destroy, etc…)
- Application Orchestrator - Orchestrate services to serve up an application
- Artifact Repository - Store images, Service Templates, Application Stacks, etc…
- Cloud Broker - Distribute and manage requests to multiple clouds
- Data Coordinator - Coordinate images, and data between clouds
- Environment Manager - Manage Envinronments for the system (Dev, Test, Production, etc…)
- Identity Manager - Manage identity of the user across multiple clouds
- Operations Manager - Operations Portal for managing Operations and Stack development.
- Policy Manager - Manage Policies for execution of services and applications in the system
- Provision Engine - Provision services and application on resources from the cloud
- Stack Manager - Manage reusable application and service stacks.
- Telemetry - Telemety Bus from multiple clouds, services and application stacks.
Process Architecture¶
The subsystems of C3 request information from each other to accomplish the use cases of the system. This diagram shows how these microservices are connected and what they share between each other.
Deployment Model¶
The architecture consists of several micro services that form the application this diagram shows how those microservices are connected together, deployed and storage requirements.
Physical Architecture¶
This is the physical layout of microservices on the nodes in a Cloud or multiple Clouds.
Services¶
These are the micro-services of the c3 Solution that are used to implement the solutions.
Services¶
The system is implemented using micro-services that are deployed across a cloudified architecture.
app-analyzer¶
app-analyzer is a micro-service of C3 Architecture and implements parts of the Application Analyzer
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
app-orchestrator¶
app-orchestrator is a micro-service of c3 …
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
cloud-broker¶
cloud-broker is a micro-service of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
cloud-proxy¶
cloud-proxy is a micro-service of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
data-coordinator¶
data-coordinator is a micro-service of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This is the deployment of the micro-service. The micro-service is deployed when trigger and should scale from # to # based on condition. The micro-service is deployed with the imagename image. The ports exposed are 5000 for external and 3000 for internal.
Physical Architecture¶
The micro-services are physically deployed on to a hybrid cloud infrastructure.
Sub Systems¶
These are the high level Subsystems of the c3 Solution
- Application Analyzer
- Application Manager
- Application Orchestrator
- Artifact Repository
- Cloud Broker
- Data Coordinator
- Environment Manager
- Identity Manager
- Operations Manager
- Policy Manager
- Provision Engine
- Stack Manager
- Telemetry
Application Analyzer¶
The Application Analyzer is responsible for building deep learning models of application stacks, their services and resources they run and consume to optimize the execution landscape for the application.
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Application Analyzer subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Micro Services¶
These are the micro-services for the subsystem. The combination of the micro-services help implement the subsystem’s logic.
Application Manager¶
Application Manager is the primary interface for the Application Developer for C3. It enables the developer to Use Application Stacks to rapidly develop, debug and deploy “Cloud Aware” applications.
Use Cases¶
- Launch Application
- Select Application Stack
- Select Environment
- Debug App
- Create Application Stack
- Update Application Stack
- Destroy Application Stack
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
The Application Manager subsystem provides the following activities and flows.
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Application Manager subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Application Orchestrator¶
Application Orchestrator is responsible for taking the Application Stack definition and coordinating the provisioning of resources in the Cloud through the Cloud Broker. And then installing and configuring software stacks on the resources in a coordinated manner.
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
The Application Orchestrator subsystem provides the following activities and flows.
- Select an Application
- Launch Application
- Rebalance Application
- Deploy Service
- Deploy Software
Launch Application¶
When an application is launched the environment and application are used to select a “Stacklet” A Stacklet is an version of the Stack for the specific environmentment. The Stacklet defines what services, configuration, and policies are established for the paplication in the environment. Once the Stacklet is chosen (Simple selection application + environment) then the stacklet is traversed to find the services for the environment. Since Services can be simple (Simple image to instantiate) or complex (a aggregated nested network of services). The Services are travered to create a graph of Service Instances that are aggregated just as the Service graph is laid out.
A design decision was made to only bind the Service graph to the application when the application is launched. This late binding allows for quick changes to the application deinition through modification to service definitions. To limit the amount of change to the application stack, a version of the stacks can be used to “lock in” a specific version of the service definitions (stacks). The late binding also gives the ability to change multiple micro-services at the same time and test the changes in different environments, quickly without the lengthy process.
Mapping Service Insances to Cloud Resources
Instead of sending individual requests to the cloud broker a decision was made to send multiple requests at the same time giving the cloud broker the ability to map responses to the requests in batches instead of individually. This should increase thruput and give flexiibility to the Application Orchestrator. It cna send individual request or an array of requests. An example of a single request to the cloud broker is as follows:
let request = { instance:serviceInstance, policies: [], requirements: [
{type: 'compute', quantity: 1},
{type: 'storage', name:'myStorage', quantity:1000},
{name:'myNetwork', quantity:2}
]};
The design decision has to be made on when to ask for the requests of the Cloud Broker. While the Service graph is being traversed and created, or after the complete graph is created and then sent as one big request to the brokers.
Design Discussion
July 15, 2018
Should I get resources right now. Or map the resources at the highest level of the Service graph.
Pros: If I map them right now I can reuse this method to incrementally add instances and the resources cooresponding to them.
Cons: If I push this to the top then I only have to do the mapping or request to the cloud broker once with the complete set of requests. This could mean I could optimize before I send the request. This is find for the first request coming from launch but there would be no advantage during the subsquent incremental change in service increments or decrements. For now leave it here to get the basic functionality working
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Application Orchestrator subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Micro Services¶
These are the micro-services for the subsystem. The combination of the micro-services help implement the subsystem’s logic.
Artifact Repository¶
Artifact-Repository is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Artifact Repository subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Cloud Broker¶
Cloud Broker is responsible for allocating resources on the Clouds attached to C3. Based of policies it will select the “right” cloud or clouds for the application to run. This can include selecting multiple clouds for complex hybrid cloud workloads. It is the main interface to the SDI Public and Private clouds. Including VMWare, Containers, OpenStack, AWS, Google Cloud, etc…
Uses¶
- Policy Manager
- Cloud
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Logical Artifacts¶
- Resource - Virtual Representation of the hardware. This can be a VM, Bare metal, or container.
- Cloud - SDI Cloud that is connected to the data center
- Request - Request tied to a Service Instance. This is sent to the Cloud to request resources. The cloud in response is a reservation.
- Resource Request - Each request has 1..n Resource Requests. This could be compute, network, storage or accelerator.
- Reservation - This is the response to a request.
Activities and Flows¶
When an application is launched or rebalanced the Cloud broker takes the reguest of requirements for the service graph, and then evaluates the policies across the service graph, environment, and clouds. Then the Cloud Broker sends requests to each Cloud in the form of a resource requests which Service Instances with Resource Requests. Each request is sent to the individual request. In repsonse a reservation is returned from the cloud. A reservation has a “good til” time on it. Each Cloud will return a set of reservations that can be used to satisfy the request requirements. A set of reservations is then selected by the cloud broker and the rest or released/destroyed. Then a set of resources are then mapped to the reservations and the Service Instances are mapped to the resources.
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Cloud Broker subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Data Coordinator¶
Data-Coordinator is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
Micro-Services¶
Environment Manager¶
Environment Manager is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Environment Manager subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Micro-Services¶
TBD
Identity Manager¶
Identity Manager is a subsystem of C3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Identity Manager subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Operations Manager¶
Operations Manager is a subsystem of C3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Operations Manager subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Policy Manager¶
Policy Manager is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Policy Manager subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Provision Engine¶
Provision Engine is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Provision Engine subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Stack Manager¶
Stack-Manager is a subsystem of c3 …
Uses¶
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
Physical Architecture¶
Telemetry¶
Telemetry is a subsystem of c3 …
Uses¶
- Application
- Cloud
Interface¶
- CLI - Command Line Interface
- REST-API -
- Portal - Web Portal
Activities and Flows¶
Deployment Architecture¶
This subsystem is deployed using micro-services as shown in the diagram below. The ‘micro’ module is used to implement the micro-services in the system. The subsystem also has an CLI, REST and Web Interface exposed through a sailajs application. The sailsjs application will interface with the micro-services and can monitor and drive work-flows through the mesh of micro-services.
Physical Architecture¶
The Telemetry subsystem is is physically laid out on a hybrid cloud infrastructure. Each microservice is shown how they connect to each other. All of the micro-services communicate to each other and the main app through a REST interface. A CLI, REST or Web interface for the app is how other subsystems or actors interact. Requests are forwarded to micro-services through the REST interface of each micro-service.
Actors¶
These are the Actors of the System.
Developer¶
The Application Developer develops cloud aware applications, and deploys them in the C3 system.
Use Cases¶
Typical Workflow¶
Application Developers all work in different ways. This workflow show some possible workflows for the typical application developer.
User Interface¶
Mock up User Interface for the Application Developer.
Command Line Interface¶
The command line for the Developer uses the ‘c3 app’ command. For details see the scenarios.
# c3 app checkhealth [options] Check the Health of the Application Instance
# c3 app create [options] Create Application with stack and name
# c3 app debug [options] Debug an application
# c3 app deploy [options] Deploy an application
# c3 app destroy [options] Destroy(remove) an application
# c3 app get [options] Get an Application
# c3 app kill [options] Kill an Application
# c3 app launch [options] Launch and Application into a environment with a config
# c3 app list [options] List applications
# c3 app publish [options] Publish an Application
# c3 app rebalance [options] Rebalance an Application on an environment
# c3 app run [options] Run a command in the context of an application by environment.
Operations Manager¶
The Operation Manager is responsible for managing the operations of the system. This includes the creation and management of environments, users, and connectivity to the Clouds.
Use Cases¶
- Manage Environments
- Manage Policies
- Manage Applications
- Manage Infrastructure
- Manage Users
- Manage Clouds
Typical Workflow¶
Use Cases¶
Activities¶
Workflow¶
Command Line Interface¶
c3 command line interface for the Operations Manager
Manage Environments
# c3 env create [options] Create Environment
# c3 env destroy [options] Destroy an Environment
# c3 env get [options] Get details about an Environment
# c3 env list [options] List Environments
# c3 env update [options] Update Environment
Manage Policies
# c3 policy check [options] Check policy
# c3 policy create [options] Create a policy for a cloud, environment, or globally
# c3 policy destroy [options] Destroy policy
# c3 policy disable [options] Disable Policy
# c3 policy enable [options] Enable Policy
# c3 policy list [options] List Policies
# c3 policy update [options] Update Policy
Manage Applications
# c3 app checkhealth [options] Check the Health of the Application Instance
# c3 app create [options] Create Application with stack and name
# c3 app debug [options] Debug an application
# c3 app deploy [options] Deploy an application
# c3 app destroy [options] Destroy(remove) an application
# c3 app get [options] Get an Application
# c3 app kill [options] Kill an Application
# c3 app launch [options] Launch and Application into a environment with a config
# c3 app list [options] List applications
# c3 app publish [options] Publish an Application
# c3 app rebalance [options] Rebalance an Application on an environment
# c3 app run [options] Run a command in the context of an application by environment.
Manage Infrastructure
# c3 cloud create [options] Create Cloud
# c3 cloud destroy [options] Destroy Cloud
# c3 cloud list [options] List Clouds
# c3 cloud update [options] Update Cloud
# c3 hardware capacity [options] Capacity Planning of hardware
# c3 hardware create [options] Create Hardware
# c3 hardware destroy [options] Destroy Hardware
# c3 hardware list [options] List Hardware
# c3 hardware populate [options] Populate Hardware to a Cloud (Multi Create)
# c3 hardware update [options] Update Hardware
Manage Users
# c3 user create [options] Create User
# c3 user destroy [options] Destroy User
# c3 user list [options] List Users
# c3 user update [options] Update User
Manage Cloud
# c3 cloud create [options] Create Cloud
# c3 cloud destroy [options] Destroy Cloud
# c3 cloud list [options] List Clouds
# c3 cloud update [options] Update Cloud
Stack Developer¶
The Stack Developer is responsible for developing Application Stack and Service Templates
Use Cases¶
Primary Workflow¶
This represents a typical workflow of the stack developer. Not all steps in the workflow need to be taken in order. This just represents a typical workflow.
Use Cases¶
Activities¶
Workflow¶
Command Line Interface¶
c3 Command line interface for the template, stack and application commands.
Template Command
# c3 template create [options] Create Template
# c3 template destroy [options] Destroy Template
# c3 template disable [options] Disable Template
# c3 template enable [options] Enable Template
# c3 template get [options] Get Template
# c3 template publish [options] Publish Template
# c3 template test [options] Test Template
# c3 template update [options] Update Template
Stack command
# c3 stack create [options] Create Stack
# c3 stack debug [options] Debug Stack
# c3 stack destroy [options] Destroy Stack
# c3 stack list [options] List Stacks
# c3 stack publish [options] Publish Stack
# c3 stack update [options] Update Stack
Use Cases¶
Manage Application Stack¶
Manage Application Stacks, and Service Stacks.
Actors¶
Detail Scenarios¶
Create Application Stack¶
Create Application Stack using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 stack create <parameters>
# c3 stack create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
stack/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Debug Application Stack¶
Debug Application Stack using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 stack debug <parameters>
# c3 stack debug exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
stack/debug
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy Application Stack¶
Destroy Application Stack using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 stack destroy <parameters>
# c3 stack destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
stack/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Publish Application Stack¶
Publish Application Stack using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 stack publish <parameters>
# c3 stack publish exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
stack/publish
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Update Application Stack¶
Update Application Stack using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 stack update <parameters>
# c3 stack update exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
stack/update
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_
Manage Applications¶
Manage Applications is performed by the Developer.
Detail Scenarios¶
Check Application Health¶
Check Application Health using CLI and Web Interface with application name.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 application check --name <string>
# c3 application check --name myApp
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is the definition of the RESTful interface for the system.
application/check
| Name | Value | Description |
| name | string | Application Name |
Create App¶
Create App using CLI and Web Interface with name and the name of the application stack to use as the template.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app create --name <string> --stack <string>
# c3 app create --name myApp --stack lamp
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/create
| Name | Value | Description |
| name | string | Name of the application |
| stack | string | Name of the stack to use for the application |
Create Application¶
Application Develop interacts with the Application manager to create an Application. A json or yaml representation of the application is downloaded to the working directory of the project for the application.
User
Systems
Command Line Interface
Create a new application from the selected stack
# c3 app create <Application Name> --stack <Application Stack>
Debug App¶
TBD
Debug App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app debug <parameters>
# c3 app debug exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/debug
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Deploy App¶
TBD
Deploy App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app deploy <parameters>
# c3 app deploy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/deploy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy App¶
Destroy App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app destroy <parameters>
# c3 app destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Get App¶
Get App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app get <parameters>
# c3 app get exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/get
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Get Application¶
An Developer may want to connect to an existing application and clone the application definition. This allows then to connect to an application and “download” the definition of the application into their current working directory. It is represented as a set of yaml or json files.
Users
Systems
Command Line Interface
# C3 app clone <Application Name> [--version=<Application Version>]
# c3 app clone testApp --version 1.0.2
Kill App¶
Kill App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app kill <parameters>
# c3 app kill exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/kill
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Launch Application¶
Launch App using CLI and Web Interface with name and environment with an optional config file.
CLI
The Developer can launch the application from the command line into different environments.
# c3 app launch --name <string> --env <string> --config <filename>
# c3 app launch --name alert --env local --config config.yaml
Web
Mock up web interface for the scenario.
Simplified Web Interface
REST
This is an example of the RESTful interface for the scenario.
app/launch
| Name | Value | Description |
| name | string | name of the application |
| env | string | name of the environment |
| config | filename | name of the yaml config file for the application |
List Apps¶
List App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app list <parameters>
# c3 app list exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Publish App¶
Publish App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app publish <parameters>
# c3 app publish exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/publish
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Rebalance Application¶
Rebalance Application using CLI and Web Interface with application name. This will rebalance the application across the environment and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 application rebalance --name <string>
# c3 application rebalance --name myApp
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
application/rebalance
| Name | Value | Description |
| name | string | Application name to rebalance |
Run App¶
Run App using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 app run <parameters>
# c3 app run exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
app/run
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_
Manage Clouds¶
Manage Clouds is performed by the Operations Manager.
Actors¶
Detail Scenarios¶
Create Cloud¶
Create Cloud using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 cloud create --name <string> --type <string>
# c3 cloud create --name myCloud --type aws
# c3 cloud create --name myCloud2 --type openstack
# c3 cloud create --name myCloud3 --type vmware
# c3 cloud create --name myCloud4 --type gce
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
cloud/create
| Name | Value | Description |
| name | string | Name of the cloud to install in the simulation |
| type | string | Type of Cloud (aws,gce,ibm,openstack,vmware) |
Destroy Clouds¶
Destroy Clouds using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 cloud destroy --name <string>
# c3 cloud destroy --name myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
cloud/destroy
| Name | Value | Description |
| name | string | Name of the cloud to destroy |
List Clouds¶
List Clouds using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 cloud list
Name Type
========= =========
MyCloud aws
MyCloud2 openstack
MyCloud3 vmware
MyCloud4 gce
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
cloud/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Map Images¶
Map Images using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 cloud images <parameters>
# c3 cloud images exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
cloud/images
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Map Machine Types¶
Map Machine Types using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 machine create <parameters>
# c3 machine create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
machine/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Map Resources¶
Map Resources using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 resource create <parameters>
# c3 resource create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
resource/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
Manage Environments¶
The Operations Manager manages environments and the Developer uses the environments to develop,test and deploy applications and services.
Actors¶
Detail Scenarios¶
Create Environment¶
Create Environment using CLI and Web Interface with a specified name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env create --name <string>
# c3 env create --name dev
# c3 env create --name test
# c3 env create --name prod
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/create
| Name | Value | Description |
| name | string | Name of the environment |
Destroy Environment¶
Destroy Environment using CLI and Web Interface with a specific name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env destroy --name <string>
# c3 env destroy --name test
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/destroy
| Name | Value | Description |
| name | string | Name of the environment to destroy |
Get Environment¶
Get Environment using CLI and Web Interface with specific name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env get <parameters>
# c3 env get exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/get
| Name | Value | Description |
| name | string | Name of the environment to get |
List Environments¶
List Environments using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env list
dev
test
prod
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/list
| Name | Value | Description |
Select Environment¶
Select Environment using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env select --name <string>
# c3 env select --name dev
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/select
| Name | Value | Description |
| name | string | Name of the environment to use. |
Update Environment¶
Update Environment using CLI and Web Interface with specific name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 env update --name <string>
# c3 env update --name dev
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
env/update
| Name | Value | Description |
| name | string | Name of the environment to update. |
Systems Involved¶
Manage Infrastructure¶
_Description_
Actors¶
- _Actors_
Detail Scenarios¶
Create Compute Hardware¶
Create Compute Hardware using CLI and Web Interface with specific name and cloud for type and capacity.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware create --name <string> --type compute --capacity <number> --cloud <string>
# c3 hardware create --name myCompute --type compute --capacity 28 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/create
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “compute” |
| capacity | number | number of cores |
| cloud | string | name of the cloud |
Create Network Hardware¶
Create Network Hardware using CLI and Web Interface with name and cloud for capacity and type.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware update --name <string> --type network --capacity <number> --cloud <string>
# c3 hardware update --name myNetwork --type network --capacity 254 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/create
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “network” |
| capacity | number | in network connections |
| cloud | string | name of the cloud |
Create Storage Hardware¶
Create Storage Hardware using CLI and Web Interface with name and cloud for capacity and type. Capacity is in TBytes.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware update --name <string> --type storage --capacity <number> --cloud <string>
# c3 hardware update --name myStorage --type storage --capacity 100 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/create
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “storage” |
| capacity | number | in TBytes |
| cloud | string | name of the cloud |
Destroy Compute Hardware¶
Destroy Compute Hardware using CLI and Web Interface with name and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware destroy --name <string> --cloud <string>
# c3 hardware destroy --name myCompute --cloud myCloud
# c3 hardware destroy --name myCompute
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/destroy
| Name | Value | Description |
| name | string | Required: name of the hardware |
| cloud | string | name of the cloud |
Destroy Network Hardware¶
Destroy Network Hardware using CLI and Web Interface with name and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware destroy --name <string> --cloud <string>
# c3 hardware destroy --name myNetwork --cloud myCloud
# c3 hardware destroy --name myNetwork
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/destroy
| Name | Value | Description |
| name | string | Required: name of the hardware |
| cloud | string | name of the cloud |
Destroy Storage Hardware¶
Destroy Storage Hardware using CLI and Web Interface with name and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware destroy --name <string> --cloud <string>
# c3 hardware destroy --name myStorage1 --cloud myCloud
# c3 hardware destroy --name myStorage1
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/destroy
| Name | Value | Description |
| name | string | Required: name of the hardware |
| cloud | string | name of the cloud |
List Hardware¶
List Hardware using CLI and Web Interface for a specific cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware list --cloud <string>
# c3 hardware list --cloud myCloud
Name Type available capacity Cloud
======== ======== ========= ======== ======
myComi compute 27 28 myCloud
myCom2 compute 27 28 myCloud
myCom3 compute 27 28 myCloud
myNet1 network 230 254 myCloud
myStore1 storage 90 100 myCloud
myStore2 storage 80 100 myCloud
# c3 hardware list # all hardware on clouds listed
Name Type available capacity Cloud
======== ======== ========= ======== ======
myComi compute 27 28 myCloud
myCom2 compute 27 28 myCloud
myCom3 compute 27 28 myCloud2
myNet1 network 230 254 myCloud2
myStore1 storage 90 100 myCloud3
myStore2 storage 80 100 myCloud3
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/list
| Name | Value | Description |
| cloud | string | name of the cloud |
Plan Capacity¶
TBD
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware capacity <parameters>
# c3 hardware capacity exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/capacity
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Populate Hardware¶
Populate Hardware using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware populate --cloud <string> --filename <yaml file>
# c3 hardware populate --cloud myCloud --filename hardware.yaml
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/populate
| Name | Value | Description |
| cloud | string | Name of the cloud to populate hardware on. |
| filename | filename | file with the hardware yaml format |
** hardware ymal file format **
This is the yaml file format for the hardware specification
hardware:
<name>:
type: <hardware type>
capacity: <number>
This is an example yaml file to install 3 compute nodes, 2 storage (100 TB each) and 1 network.
hardware:
host1:
type: compute
capacity: 28
host2:
type: compute
capacity: 28
host3:
type: compute
capacity: 28
store1:
type: storage
capacity: 100
store2:
type: storage
capacity: 100
network1:
type: network
capacity: 254
Update Compute Hardware¶
Update Compute Hardware using CLI and Web Interface with specific name for capacity, type, and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware update --name <string> --type compute --capacity <number> --cloud <string>
# c3 hardware update --name myCompute --type compute --capacity 28 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/update
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “compute” |
| capacity | number | number of cores |
| cloud | string | name of the cloud |
Update Network Hardware¶
Update Network Hardware using CLI and Web Interface with specific name for capacity, type, cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware update --name <string> --type network --capacity <number> --cloud <string>
# c3 hardware update --name myNetwork --type network --capacity 254 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/update
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “network” |
| capacity | number | in network connections |
| cloud | string | name of the cloud |
Update Storage Hardware¶
Update Storage Hardware using CLI and Web Interface with specific name for capacity, type and cloud.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 hardware update --name <string> --type storage --capacity <number> --cloud <string>
# c3 hardware update --name myStorage --type storage --capacity 10000 --cloud myCloud
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
hardware/update
| Name | Value | Description |
| name | string | name of the hardware resource |
| type | string | “storage” |
| capacity | number | in TBytes |
| cloud | string | name of the cloud |
Systems Involved¶
- _Systems_
Manage Policies¶
The Operations Manager can create, update, enable, and disable the policies for a cloud, environment or globally.
Actors¶
Detail Scenarios¶
Check Policy¶
Check Policy using CLI and Web Interface with name of the policy
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy check --name <string>
# c3 policy check --name myPolicy
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/check
| Name | Value | Description |
| name | string | Required: name of the policy to check. |
Create Policy¶
Create Policy using CLI and Web Interface with name of the policy for cloud and environment with the specific filename.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy create --name <string> --cloud <string> --env <string> --filename <filename>
# c3 policy create --name myPolicy --cloud myCloud --env dev --filename policy.yaml
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/create
| Name | Value | Description |
| name | string | Required: Name of the policy to create |
| cloud | string | Name of the cloud |
| env | string | name of the environment |
| filename | filename | YAML file for the policy definition |
** Policy.YAML **
Policy YAML file format
policy:
triggers:
- events: <events name>
action: <action string>
condition: <condition string>
Example of a policy with six triggers.
policy:
triggers:
- events: accidents
action: sails.helpers.service.inc('ingestion', 10);sails.helpers.service.dec('analytics', 4);
condition: events.value>100
- events: accidents
action: sails.helpers.service.inc('ingestion', 10);sails.helpers.service.dec('analytics', 4);
condition: events.value>200
- events: accidents
action: sails.helpers.service.inc('ingestion', 10);sails.helpers.service.dec('analytics', 4);
condition: events.value>300
- events: accidents
action: sails.helpers.service.dec('ingestion', 10);sails.helpers.service.inc('analytics', 4);
condition: events.value<100
- events: accidents
action: sails.helpers.service.dec('ingestion', 10);sails.helpers.service.inc('analytics', 4);
condition: events.value<200
- events: accidents
action: sails.helpers.service.dec('ingestion', 10);sails.helpers.service.inc('analytics', 4);
condition: events.value<300
Destroy Policy¶
Destroy Policy using CLI and Web Interface with specifc name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy destroy --name <string>
# c3 policy destroy --name myPolicy
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/destroy
| Name | Value | Description |
| name | string | Name of the policy to destroy. |
Disable Policy¶
Disable Policy using CLI and Web Interface with policy name.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy disable --name <string>
# c3 policy disable --name myPolicy
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/disable
| Name | Value | Description |
| name | string | Name of the policy to disable |
Enable Policy¶
Enable Policy using CLI and Web Interface with specific name
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy enable --name <string>
# c3 policy enable --name myPolicy
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/enable
| Name | Value | Description |
| name | string | Name of the policy to enable |
List Policy¶
List Policy using CLI and Web Interface with cloud or environment.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy list --cloud <string> --env <string>
# c3 policy list --cloud myCloud --env myEnv
# c3 policy list --cloud myCloud
# c3 policy list --env myEnv
# c3 policy list
Name Cloud Environment State
======== ======== =========== ========
myPolicy myCloud myEnv enabled
myPolicy2 myCloud myEnv enabled
myPolicy3 myEnv disabled
myPolicy4 myCloud enabled
myPolicy5 disabled
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/list
| Name | Value | Description |
| cloud | string | The name of the cloud |
| env | string | The name of the environment |
Update Policy¶
Update Policy using CLI and Web Interface with specifc name for cloud and environment.
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 policy update --name <string> --cloud <string> --env <string>
# c3 policy update --name myPolicy --cloud myCloud --env dev
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
policy/update
| Name | Value | Description |
| name | string | Name of the policy to update |
| cloud | string | Name of the cloud |
| env | string | Name of the environment |
Systems Involved¶
Manage Service Template¶
_Description_
Actors¶
- _Actors_
Detail Scenarios¶
Create Service Template¶
Create Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template create <parameters>
# c3 template create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy Service Template¶
Destroy Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template destroy <parameters>
# c3 template destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Disable Service Template¶
Disable Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template disable <parameters>
# c3 template disable exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/disable
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Enable Service Template¶
Enable Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template enable <parameters>
# c3 template enable exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/enable
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Get Service Template¶
Get Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template get <parameters>
# c3 template get exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/get
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Launch and Test Service Template¶
Launch and Test Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template test <parameters>
# c3 template test exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/test
| Name | Value | Description |
| parameter1 | value1 | Description1 |
List Service Template¶
List Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template list <parameters>
# c3 template list exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Publish Service Template¶
Publish Service Template using CLI and Web Interface with … <parameters>
CLI
This shows how a user can interact with the system via the command line.
# c3 template publish <parameters>
# c3 template publish exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/publish
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Update Service Template¶
Update Service Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template update <parameters>
# c3 template update exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/update
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_
Manage Service¶
_Description_
Actors¶
- _Actors_
Detail Scenarios¶
Create Service¶
Create Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service create <parameters>
# c3 service create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Deploy Service¶
Deploy Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service deploy <parameters>
# c3 service deploy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/deploy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy Service¶
Destroy Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service destroy <parameters>
# c3 service destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Get Service¶
Get Service using CLI and Web Interface with the name of the service. It will return a json representation of the service.
CLI
This shows how a user can interact with the system via the command line.
# c3 service get --name <string>
# c3 service get --name myService
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/get
| Name | Value | Description |
| name | string | Name of the service |
Get Service Logs¶
Get Service Logs using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service logs <parameters>
# c3 service logs exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/logs
| Name | Value | Description |
| parameter1 | value1 | Description1 |
List Service¶
List Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service list <parameters>
# c3 service list exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Publish Service¶
Publish Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service publish <parameters>
# c3 service publish exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/publish
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Test Service¶
Test Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service test <parameters>
# c3 service test exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/test
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Update Service¶
Update Service using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 service update <parameters>
# c3 service update exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
service/update
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_
Manage Stack Template¶
_Description_
Actors¶
- _Actors_
Detail Scenarios¶
Create Stack Template¶
Create Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template create <parameters>
# c3 template create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy Stack Template¶
Destroy Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template destroy <parameters>
# c3 template destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
List Stack Template¶
List Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template list <parameters>
# c3 template list exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Publish Stack Template¶
Publish Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template publish <parameters>
# c3 template publish exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/publish
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Test Stack Template¶
Test Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template test <parameters>
# c3 template test exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/test
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Update Stack Template¶
Update Stack Template using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 template update <parameters>
# c3 template update exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
template/update
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_
Manage Users¶
_Description_
Actors¶
- _Actors_
Detail Scenarios¶
Create User¶
Create User using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 user create <parameters>
# c3 user create exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
user/create
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Destroy User¶
Destroy User using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 user destroy <parameters>
# c3 user destroy exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
user/destroy
| Name | Value | Description |
| parameter1 | value1 | Description1 |
List User¶
List User using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 user list <parameters>
# c3 user list exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
user/list
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Update User¶
Update User using CLI and Web Interface with … <parameters>
CLI
This is an example of a command line interface for the user to interact with the system.
# c3 user update <parameters>
# c3 user update exmaple
Web Interface(Mock-up)
Mock up web interface for the scenario.
REST
This is an example of the RESTful interface for the scenario.
user/update
| Name | Value | Description |
| parameter1 | value1 | Description1 |
Systems Involved¶
- _Systems_