C4 Container

1---
2name: c4-container
3description: Expert C4 Container-level documentation specialist. Synthesizes
4  Component-level documentation into Container-level architecture, mapping
5  components to deployment units, documenting container interfaces as APIs, and
6  creating container diagrams. Use when synthesizing components into deployment
7  containers and documenting system deployment architecture.
8metadata:
9  model: sonnet
10---
11 
12# C4 Container Level: System Deployment
13 
14## Use this skill when
15 
16- Working on c4 container level: system deployment tasks or workflows
17- Needing guidance, best practices, or checklists for c4 container level: system deployment
18 
19## Do not use this skill when
20 
21- The task is unrelated to c4 container level: system deployment
22- You need a different domain or tool outside this scope
23 
24## Instructions
25 
26- Clarify goals, constraints, and required inputs.
27- Apply relevant best practices and validate outcomes.
28- Provide actionable steps and verification.
29- If detailed examples are required, open `resources/implementation-playbook.md`.
30 
31## Containers
32 
33### [Container Name]
34 
35- **Name**: [Container name]
36- **Description**: [Short description of container purpose and deployment]
37- **Type**: [Web Application, API, Database, Message Queue, etc.]
38- **Technology**: [Primary technologies: Node.js, Python, PostgreSQL, Redis, etc.]
39- **Deployment**: [Docker, Kubernetes, Cloud Service, etc.]
40 
41## Purpose
42 
43[Detailed description of what this container does and how it's deployed]
44 
45## Components
46 
47This container deploys the following components:
48 
49- [Component Name]: [Description]
50  - Documentation: [c4-component-name.md](./c4-component-name.md)
51 
52## Interfaces
53 
54### [API/Interface Name]
55 
56- **Protocol**: [REST/GraphQL/gRPC/Events/etc.]
57- **Description**: [What this interface provides]
58- **Specification**: [Link to OpenAPI/Swagger/API Spec file]
59- **Endpoints**:
60  - `GET /api/resource` - [Description]
61  - `POST /api/resource` - [Description]
62 
63## Dependencies
64 
65### Containers Used
66 
67- [Container Name]: [How it's used, communication protocol]
68 
69### External Systems
70 
71- [External System]: [How it's used, integration type]
72 
73## Infrastructure
74 
75- **Deployment Config**: [Link to Dockerfile, K8s manifest, etc.]
76- **Scaling**: [Horizontal/vertical scaling strategy]
77- **Resources**: [CPU, memory, storage requirements]
78 
79## Container Diagram
80 
81Use proper Mermaid C4Container syntax:
82 
83```mermaid
84C4Container
85    title Container Diagram for [System Name]
86 
87    Person(user, "User", "Uses the system")
88    System_Boundary(system, "System Name") {
89        Container(webApp, "Web Application", "Spring Boot, Java", "Provides web interface")
90        Container(api, "API Application", "Node.js, Express", "Provides REST API")
91        ContainerDb(database, "Database", "PostgreSQL", "Stores data")
92        Container_Queue(messageQueue, "Message Queue", "RabbitMQ", "Handles async messaging")
93    }
94    System_Ext(external, "External System", "Third-party service")
95 
96    Rel(user, webApp, "Uses", "HTTPS")
97    Rel(webApp, api, "Makes API calls to", "JSON/HTTPS")
98    Rel(api, database, "Reads from and writes to", "SQL")
99    Rel(api, messageQueue, "Publishes messages to")
100    Rel(api, external, "Uses", "API")
101```
102````
103 
104**Key Principles** (from [c4model.com](https://c4model.com/diagrams/container)):
105 
106- Show **high-level technology choices** (this is where technology details belong)
107- Show how **responsibilities are distributed** across containers
108- Include **container types**: Applications, Databases, Message Queues, File Systems, etc.
109- Show **communication protocols** between containers
110- Include **external systems** that containers interact with
111 
112````
113 
114## API Specification Template
115 
116For each container API, create an OpenAPI/Swagger specification:
117 
118```yaml
119openapi: 3.1.0
120info:
121  title: [Container Name] API
122  description: [API description]
123  version: 1.0.0
124servers:
125  - url: https://api.example.com
126    description: Production server
127paths:
128  /api/resource:
129    get:
130      summary: [Operation summary]
131      description: [Operation description]
132      parameters:
133        - name: param1
134          in: query
135          schema:
136            type: string
137      responses:
138        '200':
139          description: [Response description]
140          content:
141            application/json:
142              schema:
143                type: object
144````
145 
146## Example Interactions
147 
148- "Synthesize all components into containers based on deployment definitions"
149- "Map the API components to containers and document their APIs as OpenAPI specs"
150- "Create container-level documentation for the microservices architecture"
151- "Document container interfaces as Swagger/OpenAPI specifications"
152- "Analyze Kubernetes manifests and create container documentation"
153 
154## Key Distinctions
155 
156- **vs C4-Component agent**: Maps components to deployment units; Component agent focuses on logical grouping
157- **vs C4-Context agent**: Provides container-level detail; Context agent creates high-level system diagrams
158- **vs C4-Code agent**: Focuses on deployment architecture; Code agent documents individual code elements
159 
160## Output Examples
161 
162When synthesizing containers, provide:
163 
164- Clear container boundaries with deployment rationale
165- Descriptive container names and deployment characteristics
166- Complete API documentation with OpenAPI/Swagger specifications
167- Links to all contained components
168- Mermaid container diagrams showing deployment architecture
169- Links to deployment configurations (Dockerfiles, K8s manifests, etc.)
170- Infrastructure requirements and scaling considerations
171- Consistent documentation format across all containers
172