Text to Infrastrucutre as Code
- ✅ text2iac_project_framework - główna architektura i przykłady użycia
- ✅ text2iac_visual_solutions - wizualizacja pipeline (Mermaid-based)
- ✅ text2iac_communication_integration - integracje komunikacyjne
- ✅ local_communication_bridge - lokalne integracje bez Zapier
- 📁 Struktura folderów projektu
- 📄 Dokumentacja techniczna
- 🐳 Docker configurations
- 🔧 Core aplikacje (API, Email Bridge, Frontend)
- ⚙️ Konfiguracje (CI/CD, monitoring)
- 📋 Templates i przykłady
text2iac-platform/
├── 📄 README.md
├── 📄 LICENSE
├── 📄 .gitignore
├── 📄 .env.example
├── 📄 docker-compose.yml
├── 📄 docker-compose.dev.yml
├── 📄 Makefile
├── 📄 package.json (root)
│
├── 📁 docs/ # Dokumentacja
│ ├── 📄 ARCHITECTURE.md
│ ├── 📄 GETTING_STARTED.md
│ ├── 📄 API_REFERENCE.md
│ ├── 📄 DEPLOYMENT.md
│ ├── 📄 CONTRIBUTING.md
│ └── 📁 images/
│ ├── 🖼️ architecture-diagram.png
│ └── 🖼️ workflow-example.png
│
├── 📁 api/ # Main API Service
│ ├── 📄 Dockerfile
│ ├── 📄 package.json
│ ├── 📄 tsconfig.json
│ ├── 📁 src/
│ │ ├── 📄 index.ts
│ │ ├── 📄 app.ts
│ │ ├── 📁 controllers/
│ │ │ ├── 📄 text2iac.controller.ts
│ │ │ ├── 📄 status.controller.ts
│ │ │ └── 📄 health.controller.ts
│ │ ├── 📁 services/
│ │ │ ├── 📄 llm.service.ts
│ │ │ ├── 📄 template.service.ts
│ │ │ └── 📄 deployment.service.ts
│ │ ├── 📁 utils/
│ │ │ ├── 📄 mermaid.generator.ts
│ │ │ └── 📄 validator.ts
│ │ └── 📁 middleware/
│ │ ├── 📄 auth.middleware.ts
│ │ └── 📄 cors.middleware.ts
│ └── 📁 tests/
│ ├── 📄 app.test.ts
│ └── 📄 controllers.test.ts
│
├── 📁 email-bridge/ # Email Integration Service
│ ├── 📄 Dockerfile
│ ├── 📄 requirements.txt
│ ├── 📄 main.py
│ ├── 📁 src/
│ │ ├── 📄 email_monitor.py
│ │ ├── 📄 email_processor.py
│ │ └── 📄 response_sender.py
│ ├── 📁 config/
│ │ └── 📄 email_templates.json
│ └── 📁 tests/
│ └── 📄 test_email_processor.py
│
├── 📁 frontend/ # Simple Web Interface
│ ├── 📄 Dockerfile
│ ├── 📄 package.json
│ ├── 📁 public/
│ │ ├── 📄 index.html
│ │ ├── 📄 favicon.ico
│ │ └── 📁 assets/
│ ├── 📁 src/
│ │ ├── 📄 app.js
│ │ ├── 📄 styles.css
│ │ └── 📁 components/
│ │ ├── 📄 RequestForm.js
│ │ └── 📄 StatusDisplay.js
│ └── 📁 dist/
│
├── 📁 templates/ # IaC Templates
│ ├── 📁 terraform/
│ │ ├── 📁 modules/
│ │ │ ├── 📁 web-api/
│ │ │ │ ├── 📄 main.tf
│ │ │ │ ├── 📄 variables.tf
│ │ │ │ └── 📄 outputs.tf
│ │ │ ├── 📁 database/
│ │ │ └── 📁 monitoring/
│ │ └── 📁 examples/
│ │ ├── 📄 nodejs-api.tf
│ │ └── 📄 ecommerce-platform.tf
│ │
│ ├── 📁 kubernetes/
│ │ ├── 📁 base/
│ │ │ ├── 📄 namespace.yaml
│ │ │ ├── 📄 deployment.yaml
│ │ │ └── 📄 service.yaml
│ │ └── 📁 overlays/
│ │ ├── 📁 dev/
│ │ └── 📁 prod/
│ │
│ └── 📁 docker-compose/
│ ├── 📄 web-api-template.yml
│ └── 📄 database-template.yml
│
├── 📁 examples/ # Usage Examples
│ ├── 📄 simple-web-api.md
│ ├── 📄 ecommerce-platform.md
│ └── 📄 data-pipeline.md
│
├── 📁 scripts/ # Utility Scripts
│ ├── 📄 setup.sh
│ ├── 📄 deploy.sh
│ ├── 📄 pull-models.sh
│ └── 📄 health-check.sh
│
├── 📁 config/ # Configuration Files
│ ├── 📄 nginx.conf
│ ├── 📄 prometheus.yml
│ └── 📁 prompts/
│ ├── 📄 system-prompt.txt
│ └── 📄 terraform-prompt.txt
│
└── 📁 .github/ # CI/CD
└── 📁 workflows/
├── 📄 ci.yml
├── 📄 docker-build.yml
└── 📄 deploy.yml
- ✅ Email-to-Infrastructure - podstawowa integracja email
- ✅ Simple Web UI - formularz dla non-technical users
- ✅ LLM Integration - Ollama + Mistral 7B
- ✅ Template Generation - podstawowe Terraform/Docker Compose
- ✅ Status Tracking - proste dashboard
- ❌ Slack/Teams integration (Phase 2)
- ❌ Backstage plugin (Phase 2)
- ❌ ArgoCD integration (Phase 2)
- ❌ Advanced monitoring (Phase 2)
- ❌ Multi-cloud support (Phase 3)
- Express.js - battle-tested, minimal boilerplate
- node-fetch - HTTP client
- nodemailer - email handling
- joi - validation
- winston - logging
- Vanilla JS + CSS - zero build step, maximum simplicity
- Tailwind CDN - styling bez webpack
- No React/Vue - overkill dla MVP
- Python imaplib - built-in email handling
- requests - HTTP client
- Docker Compose - orchestration
- Nginx - reverse proxy
- PostgreSQL - state storage
- Ollama - LLM runtime
- morgan - request logging
- express-prometheus-middleware - metrics
- Docker healthchecks - basic monitoring
- 📄
README.md- project overview - 📄
docker-compose.yml- main orchestration - 📄
api/package.json- API dependencies - 📄
api/src/app.ts- main API server - 📄
api/src/controllers/text2iac.controller.ts- core logic - 📄
email-bridge/main.py- email integration - 📄
frontend/public/index.html- web interface - 📄
scripts/setup.sh- quick start script
- 📄
.env.example- environment template - 📄
config/nginx.conf- reverse proxy - 📄
api/Dockerfile- API container - 📄
email-bridge/Dockerfile- email bridge container
- 📄
templates/terraform/modules/web-api/main.tf- basic Terraform - 📄
templates/docker-compose/web-api-template.yml- Docker template - 📄
examples/simple-web-api.md- usage example
- 📄
docs/GETTING_STARTED.md- setup guide - 📄
docs/API_REFERENCE.md- API docs - 📄
.github/workflows/ci.yml- basic CI
# Clone and setup
git clone text2iac-platform
cd text2iac-platform
# Start all services
make start-dev
# Test email integration
echo "Create a simple blog" | mail -s "[TEXT2IAC] Blog Request" infrastructure@localhost
# Access web interface
open http://localhost:8080
# Check status
make health-check- ✅ Email-to-infrastructure latency < 2 minutes
- ✅ Web UI response time < 3 seconds
- ✅ 99% uptime for core services
- ✅ Zero configuration for basic usage
- 🎯 5+ successful infrastructure generations
- 🎯 2+ different template types working
- 🎯 Email integration 100% functional
- 🎯 Non-technical user can use web UI without training
Następne kroki: Generacja plików w kolejności Priority 1 → Priority 4, skupiając się na gotowych rozwiązaniach i minimalnej ilości custom kodu.
Lightweight service który monitoruje corporate email i przekazuje requesty do Text2IaC API - kompletnie wewnętrzny, zero external dependencies.
Company Email Server → Email Monitor → Text2IaC API → Infrastructure
↓ ↓ ↓ ↓
IMAP/SMTP Python Bot LLM Engine Backstage
Internal Container Ollama ArgoCD
# email_bridge.py - 50 lines of code!
import imaplib
import email
import json
import requests
import smtplib
from email.mime.text import MIMEText
import time
import re
class EmailBridge:
def __init__(self):
# Internal company email settings
self.imap_host = "mail.company.com" # Your Exchange/IMAP server
self.smtp_host = "mail.company.com" # Your SMTP server
self.email = "infrastructure@company.com"
self.password = "your-app-password"
self.text2iac_api = "http://localhost:3001/api/generate"
def monitor_emails(self):
"""Monitor inbox for [TEXT2IAC] emails"""
mail = imaplib.IMAP4_SSL(self.imap_host)
mail.login(self.email, self.password)
mail.select('inbox')
while True:
try:
# Check for new emails with TEXT2IAC in subject
status, messages = mail.search(None, 'UNSEEN SUBJECT "[TEXT2IAC]"')
for msg_id in messages[0].split():
# Fetch email
status, msg_data = mail.fetch(msg_id, '(RFC822)')
email_msg = email.message_from_bytes(msg_data[0][1])
# Process infrastructure request
self.process_request(email_msg)
time.sleep(30) # Check every 30 seconds
except Exception as e:
print(f"Error monitoring emails: {e}")
time.sleep(60)
def process_request(self, email_msg):
"""Extract request and send to Text2IaC"""
sender = email_msg['From']
subject = email_msg['Subject']
# Extract body text
body = ""
if email_msg.is_multipart():
for part in email_msg.walk():
if part.get_content_type() == "text/plain":
body = part.get_payload(decode=True).decode()
else:
body = email_msg.get_payload(decode=True).decode()
# Parse request
request_data = {
"description": body,
"requestor": sender,
"subject": subject,
"timestamp": time.time()
}
try:
# Send to Text2IaC API
response = requests.post(self.text2iac_api,
json=request_data,
timeout=30)
if response.status_code == 200:
result = response.json()
self.send_success_response(sender, result)
else:
self.send_error_response(sender, "API Error")
except Exception as e:
self.send_error_response(sender, str(e))
def send_success_response(self, recipient, result):
"""Send success email with links"""
msg = MIMEText(f"""
✅ Infrastructure Request Processed Successfully!
Service Name: {result.get('name', 'Generated Service')}
Status: {result.get('status', 'Processing')}
🔗 Track Progress:
• Backstage: {result.get('backstage_url', 'http://backstage.company.com')}
• Deployment: {result.get('argocd_url', 'http://argocd.company.com')}
• Monitoring: {result.get('grafana_url', 'http://grafana.company.com')}
⏱️ ETA: {result.get('eta', '15 minutes')}
Generated Infrastructure:
{result.get('summary', 'Infrastructure components are being created...')}
--
Text2IaC Automation System
""")
msg['Subject'] = f"✅ Infrastructure Ready: {result.get('name', 'Service')}"
msg['From'] = self.email
msg['To'] = recipient
self.send_email(msg)
def send_error_response(self, recipient, error):
"""Send error notification"""
msg = MIMEText(f"""
❌ Infrastructure Request Failed
Error: {error}
Please check your request format and try again.
Example format:
Subject: [TEXT2IAC] My Service Name
Create a Node.js API with:
- PostgreSQL database
- Redis cache
- Monitoring setup
- Auto-scaling
--
Text2IaC Automation System
""")
msg['Subject'] = "❌ Infrastructure Request Error"
msg['From'] = self.email
msg['To'] = recipient
self.send_email(msg)
def send_email(self, msg):
"""Send email via company SMTP"""
try:
server = smtplib.SMTP(self.smtp_host, 587)
server.starttls()
server.login(self.email, self.password)
server.send_message(msg)
server.quit()
except Exception as e:
print(f"Error sending email: {e}")
if __name__ == "__main__":
bridge = EmailBridge()
print("Starting Email Bridge...")
bridge.monitor_emails()# Dockerfile
FROM python:3.11-slim
WORKDIR /app
# Install dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt
# Copy application
COPY email_bridge.py .
COPY config.json .
# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
CMD python -c "import requests; requests.get('http://localhost:8080/health')"
CMD ["python", "email_bridge.py"]# requirements.txt
requests==2.31.0# Add to existing docker-compose.yml
services:
# ... existing services ...
email-bridge:
build: ./email-bridge
environment:
- IMAP_HOST=mail.company.com
- SMTP_HOST=mail.company.com
- EMAIL_USER=infrastructure@company.com
- EMAIL_PASS=${EMAIL_PASSWORD}
- TEXT2IAC_API=http://text2iac-api:3000/api/generate
volumes:
- ./config:/app/config
networks:
- text2iac-network
restart: unless-stopped
depends_on:
- text2iac-api// slack_bridge.js
const { App } = require('@slack/bolt');
const axios = require('axios');
const app = new App({
token: process.env.SLACK_BOT_TOKEN,
signingSecret: process.env.SLACK_SIGNING_SECRET,
socketMode: true,
appToken: process.env.SLACK_APP_TOKEN
});
// Slash command: /infra
app.command('/infra', async ({ command, ack, respond }) => {
await ack();
const description = command.text;
if (!description) {
await respond({
text: "Please provide a description. Example: `/infra Create Node.js API with database`"
});
return;
}
try {
// Call Text2IaC API
const response = await axios.post('http://localhost:3001/api/generate', {
description: description,
requestor: command.user_name,
channel: command.channel_name
});
const result = response.data;
await respond({
blocks: [
{
type: "section",
text: {
type: "mrkdwn",
text: `✅ *Infrastructure "${result.name}" created!*`
}
},
{
type: "section",
fields: [
{
type: "mrkdwn",
text: `*Status:* ${result.status}`
},
{
type: "mrkdwn",
text: `*ETA:* ${result.eta}`
}
]
},
{
type: "actions",
elements: [
{
type: "button",
text: {
type: "plain_text",
text: "📊 View in Backstage"
},
url: result.backstage_url,
action_id: "view_backstage"
},
{
type: "button",
text: {
type: "plain_text",
text: "⚡ Deployment Status"
},
url: result.argocd_url,
action_id: "view_status"
}
]
}
]
});
} catch (error) {
await respond({
text: `❌ Error creating infrastructure: ${error.message}`
});
}
});
// Interactive button for templates
app.command('/templates', async ({ command, ack, respond }) => {
await ack();
await respond({
blocks: [
{
type: "section",
text: {
type: "mrkdwn",
text: "*Choose a template:*"
}
},
{
type: "actions",
elements: [
{
type: "button",
text: { type: "plain_text", text: "🌐 Web API" },
value: "web_api",
action_id: "template_web_api"
},
{
type: "button",
text: { type: "plain_text", text: "🛒 E-commerce" },
value: "ecommerce",
action_id: "template_ecommerce"
},
{
type: "button",
text: { type: "plain_text", text: "📊 Analytics" },
value: "analytics",
action_id: "template_analytics"
}
]
}
]
});
});
// Handle template buttons
app.action(/template_.*/, async ({ body, ack, respond }) => {
await ack();
const templates = {
'template_web_api': 'Create a scalable REST API with PostgreSQL database, Redis caching, JWT authentication, and comprehensive monitoring.',
'template_ecommerce': 'Build an e-commerce platform with product catalog, shopping cart, payment processing, inventory management, and analytics.',
'template_analytics': 'Create an analytics platform with data ingestion pipeline, real-time processing, interactive dashboards, and automated reporting.'
};
const template = templates[body.actions[0].action_id];
// Auto-trigger infrastructure creation
try {
const response = await axios.post('http://localhost:3001/api/generate', {
description: template,
requestor: body.user.name,
channel: body.channel.name,
template: true
});
const result = response.data;
await respond({
text: `✅ Template "${result.name}" deployed! Track: ${result.backstage_url}`
});
} catch (error) {
await respond({
text: `❌ Template deployment failed: ${error.message}`
});
}
});
// Listen for mentions in channels
app.event('app_mention', async ({ event, say }) => {
const text = event.text.replace(/<@.*?>/, '').trim();
if (text.toLowerCase().includes('create') || text.toLowerCase().includes('generate')) {
await say({
text: `I can help create infrastructure! Use \`/infra ${text}\` or choose from templates with \`/templates\``
});
}
});
(async () => {
await app.start(3000);
console.log('⚡️ Slack bridge is running!');
})();{
"name": "slack-bridge",
"version": "1.0.0",
"main": "slack_bridge.js",
"dependencies": {
"@slack/bolt": "^3.17.1",
"axios": "^1.6.0"
},
"scripts": {
"start": "node slack_bridge.js"
}
}# teams_bridge.py
from flask import Flask, request, jsonify
import requests
import json
app = Flask(__name__)
@app.route('/webhook', methods=['POST'])
def teams_webhook():
"""Handle Teams webhook messages"""
data = request.json
# Extract message
message_type = data.get('type')
if message_type == 'message':
text = data.get('text', '')
sender = data.get('from', {}).get('name', 'Unknown')
# Check if it's an infrastructure request
if '[INFRA]' in text.upper() or text.startswith('/infra'):
description = text.replace('[INFRA]', '').replace('/infra', '').strip()
# Process request
result = process_infrastructure_request(description, sender)
# Send response to Teams
response_data = {
"type": "message",
"text": f"✅ Infrastructure '{result['name']}' created!\n\n"
f"📊 Backstage: {result['backstage_url']}\n"
f"⚡ Status: {result['argocd_url']}"
}
return jsonify(response_data)
return jsonify({"status": "ok"})
def process_infrastructure_request(description, requestor):
"""Send request to Text2IaC API"""
try:
response = requests.post('http://localhost:3001/api/generate',
json={
'description': description,
'requestor': requestor
})
return response.json()
except Exception as e:
return {
'name': 'Error',
'status': f'Failed: {str(e)}',
'backstage_url': '#',
'argocd_url': '#'
}
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)<!DOCTYPE html>
<html>
<head>
<title>Text2IaC Communication Hub</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body { font-family: Arial, sans-serif; line-height: 1.6; color: #333; background: #f4f4f4; }
.container { max-width: 1200px; margin: 0 auto; padding: 20px; }
.header { background: #2c3e50; color: white; padding: 20px; text-align: center; margin-bottom: 30px; }
.grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }
.card { background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
.form-group { margin-bottom: 15px; }
label { display: block; margin-bottom: 5px; font-weight: bold; }
input, textarea, select { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; }
button { background: #3498db; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; }
button:hover { background: #2980b9; }
.status { padding: 10px; margin: 10px 0; border-radius: 4px; }
.success { background: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
.error { background: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
.channels { display: flex; gap: 10px; flex-wrap: wrap; margin: 20px 0; }
.channel { padding: 5px 10px; background: #e9ecef; border-radius: 15px; font-size: 12px; }
</style>
</head>
<body>
<div class="header">
<h1>🚀 Text2IaC Communication Hub</h1>
<p>Generate infrastructure from any communication channel</p>
</div>
<div class="container">
<div class="grid">
<!-- Main Request Form -->
<div class="card">
<h3>📝 Create Infrastructure Request</h3>
<form id="infraForm">
<div class="form-group">
<label for="description">Description (Plain English)</label>
<textarea id="description" rows="4"
placeholder="Create a blog website with user comments, admin panel, and email notifications..."></textarea>
</div>
<div class="form-group">
<label for="requestor">Your Name/Email</label>
<input type="text" id="requestor" placeholder="john.doe@company.com">
</div>
<div class="grid" style="grid-template-columns: 1fr 1fr; gap: 10px;">
<div class="form-group">
<label for="environment">Environment</label>
<select id="environment">
<option value="development">Development</option>
<option value="staging">Staging</option>
<option value="production">Production</option>
</select>
</div>
<div class="form-group">
<label for="priority">Priority</label>
<select id="priority">
<option value="low">Low</option>
<option value="medium">Medium</option>
<option value="high">High</option>
<option value="critical">Critical</option>
</select>
</div>
</div>
<button type="submit">✨ Generate Infrastructure</button>
</form>
<div id="result" style="display: none;"></div>
</div>
<!-- Active Channels -->
<div class="card">
<h3>📡 Active Communication Channels</h3>
<div class="channels">
<div class="channel">📧 Email Bridge</div>
<div class="channel">💬 Slack Bot</div>
<div class="channel">👥 Teams Webhook</div>
<div class="channel">📱 Telegram Bot</div>
</div>
<h4>How to Use:</h4>
<ul style="margin: 10px 0; padding-left: 20px;">
<li><strong>Email:</strong> Send to infrastructure@company.com with [TEXT2IAC] in subject</li>
<li><strong>Slack:</strong> Use /infra command or mention @text2iac</li>
<li><strong>Teams:</strong> Type [INFRA] or /infra in any chat</li>
<li><strong>Telegram:</strong> Message @text2iac_bot</li>
</ul>
</div>
<!-- Recent Requests -->
<div class="card">
<h3>📊 Recent Requests</h3>
<div id="recentRequests">
<div style="padding: 10px; border-bottom: 1px solid #eee;">
<strong>E-commerce API</strong><br>
<small>by john.doe@company.com via Slack</small><br>
<span style="color: green;">✅ Deployed</span>
</div>
<div style="padding: 10px; border-bottom: 1px solid #eee;">
<strong>Analytics Dashboard</strong><br>
<small>by jane.smith@company.com via Email</small><br>
<span style="color: orange;">⏳ Processing</span>
</div>
</div>
</div>
<!-- System Status -->
<div class="card">
<h3>🔧 System Status</h3>
<div id="systemStatus">
<div style="display: flex; justify-content: space-between; margin: 10px 0;">
<span>Email Bridge</span>
<span style="color: green;">🟢 Online</span>
</div>
<div style="display: flex; justify-content: space-between; margin: 10px 0;">
<span>LLM Engine (Mistral 7B)</span>
<span style="color: green;">🟢 Online</span>
</div>
<div style="display: flex; justify-content: space-between; margin: 10px 0;">
<span>Backstage Portal</span>
<span style="color: green;">🟢 Online</span>
</div>
<div style="display: flex; justify-content: space-between; margin: 10px 0;">
<span>ArgoCD Deployment</span>
<span style="color: green;">🟢 Online</span>
</div>
</div>
</div>
</div>
</div>
<script>
// Simple JavaScript for form handling
document.getElementById('infraForm').addEventListener('submit', async function(e) {
e.preventDefault();
const formData = {
description: document.getElementById('description').value,
requestor: document.getElementById('requestor').value,
environment: document.getElementById('environment').value,
priority: document.getElementById('priority').value
};
const button = e.target.querySelector('button');
button.textContent = '⏳ Generating...';
button.disabled = true;
try {
const response = await fetch('/api/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(formData)
});
const result = await response.json();
document.getElementById('result').innerHTML = `
<div class="status success">
<h4>✅ Infrastructure Created: ${result.name}</h4>
<p><strong>Status:</strong> ${result.status}</p>
<p><strong>ETA:</strong> ${result.eta}</p>
<p>
<a href="${result.backstage_url}" target="_blank">📊 View in Backstage</a> |
<a href="${result.argocd_url}" target="_blank">⚡ Deployment Status</a>
</p>
</div>
`;
document.getElementById('result').style.display = 'block';
} catch (error) {
document.getElementById('result').innerHTML = `
<div class="status error">
<h4>❌ Error</h4>
<p>${error.message}</p>
</div>
`;
document.getElementById('result').style.display = 'block';
} finally {
button.textContent = '✨ Generate Infrastructure';
button.disabled = false;
}
});
// Auto-refresh status every 30 seconds
setInterval(async () => {
try {
const response = await fetch('/api/status');
const status = await response.json();
// Update system status indicators
} catch (e) {
console.log('Status check failed');
}
}, 30000);
</script>
</body>
</html>version: '3.8'
services:
# Main Text2IaC services (from previous artifact)
text2iac-api:
build: ./api
ports:
- "3001:3000"
environment:
- OLLAMA_URL=http://ollama:11434
depends_on:
- ollama
- postgres
networks:
- text2iac-network
# Communication Bridges
email-bridge:
build: ./bridges/email
environment:
- IMAP_HOST=${COMPANY_IMAP_HOST}
- SMTP_HOST=${COMPANY_SMTP_HOST}
- EMAIL_USER=infrastructure@company.com
- EMAIL_PASS=${EMAIL_PASSWORD}
- TEXT2IAC_API=http://text2iac-api:3000/api/generate
networks:
- text2iac-network
restart: unless-stopped
slack-bridge:
build: ./bridges/slack
environment:
- SLACK_BOT_TOKEN=${SLACK_BOT_TOKEN}
- SLACK_SIGNING_SECRET=${SLACK_SIGNING_SECRET}
- SLACK_APP_TOKEN=${SLACK_APP_TOKEN}
- TEXT2IAC_API=http://text2iac-api:3000/api/generate
ports:
- "3002:3000"
networks:
- text2iac-network
restart: unless-stopped
teams-bridge:
build: ./bridges/teams
environment:
- TEXT2IAC_API=http://text2iac-api:3000/api/generate
ports:
- "5000:5000"
networks:
- text2iac-network
restart: unless-stopped
# Communication Hub (Web UI)
communication-hub:
build: ./bridges/web-hub
ports:
- "8080:80"
environment:
- TEXT2IAC_API=http://text2iac-api:3000/api/generate
networks:
- text2iac-network
restart: unless-stopped
# Core services (existing)
ollama:
image: ollama/ollama:latest
ports:
- "11434:11434"
volumes:
- ollama_data:/root/.ollama
networks:
- text2iac-network
postgres:
image: postgres:15-alpine
environment:
- POSTGRES_DB=text2iac
- POSTGRES_USER=text2iac
- POSTGRES_PASSWORD=${DB_PASSWORD}
volumes:
- postgres_data:/var/lib/postgresql/data
networks:
- text2iac-network
volumes:
ollama_data:
postgres_data:
networks:
text2iac-network:
driver: bridge| Aspekt | Zapier | Local Bridges |
|---|---|---|
| Setup Time | 30 min | 2-4 godziny |
| Monthly Cost | $20-100 | $0 |
| Dependencies | External service | Zero external |
| Customization | Limited | Unlimited |
| Security | Data goes to Zapier | 100% internal |
| Maintenance | Zero | Minimal |
| Company Control | No | Complete |
| Compliance | Zapier's compliance | Your compliance |
# Setup email bridge in 30 minutes:
git clone text2iac-platform
cd bridges/email
docker-compose up email-bridge
# Configure company email settings
# Test with infrastructure@company.com# Add Slack bot:
cd bridges/slack
# Create Slack app in company workspace
# Add bot tokens to .env
docker-compose up slack-bridge# Deploy everything:
docker-compose up -d
# All bridges: Email + Slack + Teams + Web Hub
# Zero external dependencies
# Complete local controlKey Benefits Local Approach:
- ✅ Zero monthly costs - no Zapier subscription
- ✅ Complete control - modify any behavior
- ✅ Data security - everything stays internal
- ✅ Compliance ready - meets enterprise requirements
- ✅ Unlimited customization - add any integration
- ✅ No rate limits - process as many requests as needed
Perfect for enterprises that value control, security, and cost optimization.
Wykorzystanie standardowych komunikatorów z prostą integracją przez Zapier/Make.com - zero kodowania, gotowe w 30 minut.
Email/Slack/Teams/Telegram → Zapier → Text2IaC API → Generated Infrastructure
↓ ↓ ↓ ↓
Natural Text Parser LLM Engine Backstage
Request + Router + Templates + ArgoCD
# Gmail → Text2IaC Integration
automation_workflow:
trigger: "New email to infrastructure@company.com"
filter: "Subject contains: [TEXT2IAC]"
actions:
- parse_email_body
- send_to_text2iac_api
- create_backstage_service
- reply_with_status_linkPrzykład użycia:
To: infrastructure@company.com
Subject: [TEXT2IAC] E-commerce API Request
Create a Node.js e-commerce API with:
- User authentication (JWT)
- Product catalog (PostgreSQL)
- Payment integration (Stripe)
- Auto-scaling (Kubernetes)
- Monitoring (Prometheus)
Expected traffic: 1000 req/min
Environment: Production
Timeline: ASAP
Auto-response:
✅ Request received: E-commerce API
🔗 Track progress: https://backstage.company.com/services/ecommerce-api
⏱️ ETA: 15 minutes for infrastructure generation
📋 Status: Processing with Mistral 7B...
Your infrastructure will include:
- AWS EKS cluster
- RDS PostgreSQL
- ElastiCache Redis
- Application Load Balancer
- CloudWatch monitoring
// Slack Bot Configuration
const slackBotConfig = {
app_token: process.env.SLACK_APP_TOKEN,
bot_token: process.env.SLACK_BOT_TOKEN,
shortcuts: {
"create_service": {
callback_id: "text2iac_modal",
title: "🚀 Create Infrastructure",
description: "Generate infrastructure from text"
}
},
slash_commands: {
"/infra": "Quick infrastructure generation",
"/service": "Create new service",
"/status": "Check deployment status"
}
};
// Slack Workflow Example
const slackWorkflow = {
name: "Infrastructure Request",
steps: [
{
type: "form",
fields: [
{
name: "description",
type: "textarea",
label: "Describe your infrastructure needs",
placeholder: "Create a microservice with database and monitoring..."
},
{
name: "environment",
type: "select",
options: ["development", "staging", "production"]
},
{
name: "urgency",
type: "select",
options: ["low", "medium", "high", "critical"]
}
]
},
{
type: "webhook",
url: "https://text2iac.company.com/api/generate",
method: "POST"
},
{
type: "message",
channel: "#infrastructure",
template: "✅ Infrastructure request submitted by {{user}}"
}
]
};{
"composeExtensions": [
{
"botId": "text2iac-bot",
"commands": [
{
"id": "createInfrastructure",
"title": "Create Infrastructure",
"description": "Generate infrastructure from text description",
"parameters": [
{
"name": "description",
"title": "Infrastructure Description",
"description": "Describe what you need"
}
]
}
]
}
],
"bots": [
{
"botId": "text2iac-bot",
"commandLists": [
{
"scopes": ["team", "personal"],
"commands": [
{
"title": "/infra",
"description": "Quick infrastructure generation"
},
{
"title": "/status",
"description": "Check deployment status"
}
]
}
]
}
]
}# Telegram Bot Commands
telegram_bot_commands = [
{
"command": "/start",
"description": "Start Text2IaC assistant"
},
{
"command": "/create",
"description": "Create new infrastructure"
},
{
"command": "/status",
"description": "Check deployment status"
},
{
"command": "/help",
"description": "Show available commands"
}
]
# Telegram Workflow
async def handle_message(update, context):
message = update.message.text
if message.startswith('/create'):
# Show inline keyboard for quick options
keyboard = [
[InlineKeyboardButton("🌐 Web API", callback_data='web_api')],
[InlineKeyboardButton("📊 Analytics Platform", callback_data='analytics')],
[InlineKeyboardButton("🛒 E-commerce", callback_data='ecommerce')],
[InlineKeyboardButton("✍️ Custom Description", callback_data='custom')]
]
reply_markup = InlineKeyboardMarkup(keyboard)
await update.message.reply_text(
"What type of infrastructure do you need?",
reply_markup=reply_markup
)
elif not message.startswith('/'):
# Direct text processing
await process_infrastructure_request(update, message)Zapier umożliwia łączenie Slack, Telegram, Email z API bez kodowania - ponad 5000 dostępnych integracji
name: "Text2IaC Multi-Channel Integration"
triggers:
- platform: gmail
filter: "to:infrastructure@company.com"
- platform: slack
channel: "#infrastructure-requests"
filter: "message contains: @text2iac"
- platform: telegram
bot: "@text2iac_bot"
command: "/create"
- platform: teams
mention: "@Text2IaC"
actions:
1. parse_request:
service: "text-parser-api"
extract: ["description", "environment", "urgency"]
2. generate_infrastructure:
service: "text2iac-api"
endpoint: "/api/generate"
method: "POST"
3. create_backstage_entry:
service: "backstage-api"
endpoint: "/api/catalog/entities"
4. deploy_via_argocd:
service: "argocd-api"
endpoint: "/api/v1/applications"
5. notify_requestor:
platforms: ["original_channel"]
template: "Infrastructure ready: {{backstage_link}}"[Gmail Trigger] → [Text Parser] → [HTTP Request to Text2IaC]
↓ ↓ ↓
[Filter by Subject] → [Data Mapper] → [Backstage Creator]
↓ ↓ ↓
[Slack Notification] ← [Status Checker] ← [ArgoCD Deployer]
No-code platformy pozwalają nietechnicznym użytkownikom tworzyć aplikacje bez kodowania - Bubble, Microsoft Power Apps, Glide
<!DOCTYPE html>
<html>
<head>
<title>Text2IaC - Infrastructure Generator</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">
</head>
<body class="bg-gray-50">
<div class="container mx-auto px-4 py-8">
<h1 class="text-3xl font-bold text-center mb-8">🚀 Infrastructure Generator</h1>
<div class="max-w-2xl mx-auto bg-white rounded-lg shadow-md p-6">
<form id="infraForm">
<div class="mb-4">
<label class="block text-gray-700 text-sm font-bold mb-2">
What do you want to build? (Describe in plain English)
</label>
<textarea
id="description"
class="w-full px-3 py-2 border rounded-lg focus:outline-none focus:border-blue-500"
rows="5"
placeholder="Example: I need a blog website with user comments, admin panel, and email notifications. Expected 500 visitors per day."
></textarea>
</div>
<div class="grid grid-cols-2 gap-4 mb-4">
<div>
<label class="block text-gray-700 text-sm font-bold mb-2">Environment</label>
<select id="environment" class="w-full px-3 py-2 border rounded-lg">
<option value="development">Development (Testing)</option>
<option value="staging">Staging (Pre-production)</option>
<option value="production">Production (Live)</option>
</select>
</div>
<div>
<label class="block text-gray-700 text-sm font-bold mb-2">Priority</label>
<select id="priority" class="w-full px-3 py-2 border rounded-lg">
<option value="low">Low (Within a week)</option>
<option value="medium">Medium (Within 3 days)</option>
<option value="high">High (Within 24 hours)</option>
<option value="critical">Critical (ASAP)</option>
</select>
</div>
</div>
<button
type="submit"
class="w-full bg-blue-500 text-white py-2 px-4 rounded-lg hover:bg-blue-600 transition duration-200"
>
✨ Generate Infrastructure
</button>
</form>
<div id="result" class="mt-6 hidden">
<div class="bg-green-50 border border-green-200 rounded-lg p-4">
<h3 class="text-green-800 font-bold mb-2">🎉 Infrastructure Created!</h3>
<p class="text-green-700 mb-3" id="resultMessage"></p>
<div class="space-y-2">
<a href="#" id="backstageLink" class="block text-blue-600 hover:underline">
📊 View in Backstage Dashboard
</a>
<a href="#" id="statusLink" class="block text-blue-600 hover:underline">
⚡ Check Deployment Status
</a>
</div>
</div>
</div>
</div>
<!-- Quick Templates -->
<div class="max-w-4xl mx-auto mt-12">
<h2 class="text-2xl font-bold text-center mb-6">🎯 Quick Templates</h2>
<div class="grid grid-cols-1 md:grid-cols-3 gap-6">
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('blog')">
<h3 class="font-bold mb-2">📝 Blog Website</h3>
<p class="text-sm text-gray-600">WordPress with comments, admin panel, and CDN</p>
</div>
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('ecommerce')">
<h3 class="font-bold mb-2">🛒 E-commerce Store</h3>
<p class="text-sm text-gray-600">Online store with payments, inventory, and analytics</p>
</div>
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('api')">
<h3 class="font-bold mb-2">🔌 REST API</h3>
<p class="text-sm text-gray-600">Scalable API with database, auth, and monitoring</p>
</div>
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('mobile')">
<h3 class="font-bold mb-2">📱 Mobile App Backend</h3>
<p class="text-sm text-gray-600">Backend for iOS/Android with push notifications</p>
</div>
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('analytics')">
<h3 class="font-bold mb-2">📊 Analytics Dashboard</h3>
<p class="text-sm text-gray-600">Data pipeline with real-time visualizations</p>
</div>
<div class="bg-white rounded-lg shadow-md p-4 cursor-pointer hover:shadow-lg transition duration-200" onclick="useTemplate('iot')">
<h3 class="font-bold mb-2">🌐 IoT Platform</h3>
<p class="text-sm text-gray-600">Device management with time-series database</p>
</div>
</div>
</div>
</div>
<script>
// JavaScript for form handling and templates
function useTemplate(type) {
const templates = {
blog: "Create a WordPress blog with user comments, admin dashboard, automatic backups, and global CDN. Expected 1000 daily visitors.",
ecommerce: "Build an e-commerce store with product catalog, shopping cart, payment processing (Stripe), inventory management, and customer analytics. Expected 500 orders per day.",
api: "Create a REST API with user authentication, PostgreSQL database, Redis caching, rate limiting, and comprehensive monitoring. Expected 10k requests per hour.",
mobile: "Build a mobile app backend with user registration, push notifications, file uploads, real-time messaging, and analytics tracking.",
analytics: "Create an analytics dashboard with data ingestion pipeline, real-time processing, interactive charts, and automated reporting.",
iot: "Build an IoT platform with device management, time-series data storage, real-time alerts, and monitoring dashboard for 1000+ devices."
};
document.getElementById('description').value = templates[type];
}
document.getElementById('infraForm').addEventListener('submit', async function(e) {
e.preventDefault();
const description = document.getElementById('description').value;
const environment = document.getElementById('environment').value;
const priority = document.getElementById('priority').value;
// Show loading state
const button = e.target.querySelector('button');
button.innerHTML = '⏳ Generating...';
button.disabled = true;
try {
// Call Text2IaC API
const response = await fetch('/api/generate', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ description, environment, priority })
});
const result = await response.json();
// Show success message
document.getElementById('resultMessage').textContent =
`Infrastructure "${result.name}" has been created and is deploying to ${environment}.`;
document.getElementById('backstageLink').href = result.backstage_url;
document.getElementById('statusLink').href = result.status_url;
document.getElementById('result').classList.remove('hidden');
} catch (error) {
alert('Error generating infrastructure. Please try again.');
} finally {
button.innerHTML = '✨ Generate Infrastructure';
button.disabled = false;
}
});
</script>
</body>
</html>app_config:
name: "Text2IaC Mobile"
platform: "Progressive Web App"
screens:
home:
title: "Infrastructure Generator"
components:
- text_input: "Describe your needs"
- template_gallery: "Quick options"
- submit_button: "Generate"
templates:
title: "Choose Template"
components:
- list_view: "Popular templates"
- search_bar: "Find specific type"
status:
title: "Deployment Status"
components:
- progress_indicator: "Real-time updates"
- links: "Backstage & monitoring"
history:
title: "My Infrastructure"
components:
- grid_view: "Past requests"
- filter_options: "By status/date"
integrations:
- zapier_webhook: "Submit to Text2IaC API"
- push_notifications: "Status updates"
- deep_links: "Open Backstage"{
"alexa_skill": {
"invocation": "text to infrastructure",
"intents": [
{
"name": "CreateInfrastructure",
"slots": [
{
"name": "Description",
"type": "AMAZON.SearchQuery"
},
{
"name": "Environment",
"type": "Environment"
}
],
"samples": [
"Create a {Description} for {Environment}",
"I need {Description}",
"Build me {Description}"
]
}
]
},
"google_assistant_action": {
"name": "Infrastructure Generator",
"invocation": "Talk to Infrastructure Generator",
"conversations": [
{
"trigger": "create infrastructure",
"response": "What kind of infrastructure do you need?",
"follow_up": "collect_description"
}
]
}
}┌─────────────────────────────────────────────────────────────────┐
│ COMMUNICATION CHANNELS │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────┐ │
│ │ Email │ │ Slack │ │ Teams │ │Telegram│ │
│ │ Gmail │ │ Channels │ │ Bot │ │ Bot │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────┐
│ INTEGRATION LAYER │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────┐ │
│ │ Zapier │ │ Make.com │ │ Integrately │ │ Custom │ │
│ │ Workflows │ │ Scenarios │ │ Automations │ │ API │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────┐
│ TEXT2IAC CORE │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────┐ │
│ │ Parser │ │ LLM Engine │ │ Template │ │ Deploy │ │
│ │ Service │ │ Mistral 7B │ │ Generator │ │ Engine │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────────────────────────────────────────┐
│ OUTPUT CHANNELS │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────┐ │
│ │ Backstage │ │ ArgoCD │ │ Grafana │ │ GitHub │ │
│ │ Portal │ │ Status │ │ Monitoring │ │ Issues │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └────────┘ │
└─────────────────────────────────────────────────────────────────┘
- ✅ Setup: 30 minut vs inne: 2-4 tygodnie
- ✅ Zero coding - konfiguracja przez UI
- ✅ Universal - każdy ma email
- ✅ Cost: $20/month (Zapier Pro)
- ❌ Mniej interaktywne niż chat
- ❌ Async communication tylko
- ❌ Ograniczone formatting options
- Mały zespół (5-20 osób)
- Formal request process
- Dokumentacja wymagana
- ✅ Real-time collaboration
- ✅ Rich formatting - buttons, cards, etc.
- ✅ Team context - discussions in channels
- ✅ Mobile native - notifications
- ❌ Multiple platforms do maintain
- ❌ Training required per platform
- ❌ Więcej moving parts
- Średni/duży zespół (20-100+ osób)
- Agile development culture
- Technical teams
- ✅ User-friendly GUI
- ✅ Template gallery - guided experience
- ✅ Progress tracking built-in
- ✅ Mobile responsive
- ❌ Another tool to remember
- ❌ Requires hosting
- ❌ Less integrated with workflow
- Mixed technical/non-technical teams
- Self-service culture
- External stakeholders access
# Quick setup:
1. Create infrastructure@company.com
2. Setup Zapier Gmail → Text2IaC integration
3. Configure auto-responses with status links
4. Test with team
Cost: $20/month
Time: 2 hours setup# Add interactive features:
1. Install Text2IaC Slack app
2. Add slash commands (/infra, /status)
3. Create #infrastructure-requests channel
4. Setup notifications
Cost: +$0 (Slack bot)
Time: 4 hours setup# Scale to other platforms:
1. Teams bot deployment
2. Telegram integration
3. Mobile PWA launch
4. Advanced workflows
Cost: +$50/month
Time: 1 week implementationDlaczego progressive approach?
- Start simple, add complexity gradually
- Learn user preferences before investing
- Validate ROI at each step
- Minimize change management shock
Key success metrics:
- 80% of requests via integrated channels (vs manual)
- 50% reduction in infrastructure request time
- 90% user satisfaction with simplicity
- Zero training required for basic usage
This approach ensures maximum adoption with minimum friction - perfect for both technical and non-technical users.