Inwire Installation & Deployment

This guide provides an overview of how Inwire is deployed and the components that make up the platform. Whether you're setting up a local development environment or planning a production deployment, this guide will help you understand the architecture and deployment options.

Platform Architecture Overview

Inwire follows a microservices architecture where specialized services handle different aspects of the ML lifecycle. All services work together through APIs and shared infrastructure.

High-Level Architecture

                                    ┌─────────────────────────────────┐
                                    │         Frontend (Next.js)      │
                                    │     http://localhost:3000       │
                                    └───────────────┬─────────────────┘
                                                    │
                                                    ▼
┌───────────────────────────────────────────────────────────────────────────────┐
│                              API Gateway / Load Balancer                       │
└───────────────────────────────────────────────────────────────────────────────┘
        │               │               │               │               │
        ▼               ▼               ▼               ▼               ▼
┌───────────┐   ┌───────────┐   ┌───────────┐   ┌───────────┐   ┌───────────┐
│   Core    │   │  Synthex  │   │  Model    │   │ ModelOps  │   │    RAG    │
│  (Auth)   │   │  (Data)   │   │ Training  │   │ (Deploy)  │   │ (Retrieval)│
└───────────┘   └───────────┘   └───────────┘   └───────────┘   └───────────┘
        │               │               │               │               │
        └───────────────┴───────────────┴───────────────┴───────────────┘
                                        │
                                        ▼
┌───────────────────────────────────────────────────────────────────────────────┐
│                           Shared Infrastructure                                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
│  │ PostgreSQL  │  │    Redis    │  │ Object Store│  │  Monitoring │          │
│  │ (Database)  │  │ (Cache/Queue)│  │  (S3/GCS)  │  │ (Prometheus)│          │
│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘          │
└───────────────────────────────────────────────────────────────────────────────┘

Core Components

Frontend

The Inwire Frontend is a modern web application built with:

Next.js 15 with App Router for server-side rendering
TypeScript for type-safe development
Tailwind CSS and shadcn/ui for consistent styling

The frontend provides the user interface for all Inwire modules and communicates with backend services via REST APIs.

Backend Services

Each backend service is a FastAPI application (Python 3.11+) responsible for a specific domain:

Service	Purpose	Default Port
Core	Authentication, authorization, user management	18000
Synthex	Synthetic data generation and data management	18090
Model Training	Experiment tracking and training orchestration	18052
ModelOps	Model deployment and lifecycle management	18087
RAG	Retrieval-Augmented Generation pipelines	8186
Stream	Real-time data processing	8083

Shared Infrastructure

All services share common infrastructure components:

PostgreSQL — Primary database with separate schemas per service
Redis — Caching, session storage, and job queues
Object Storage — S3-compatible storage for datasets, models, and artifacts
Monitoring Stack — Prometheus, Grafana, and Jaeger for observability

Deployment Modes

Inwire supports several deployment configurations depending on your needs:

Local Development

For development and testing, Inwire can run entirely on your local machine using Docker Compose:

┌─────────────────────────────────────────┐
│            Your Development Machine      │
│  ┌─────────────────────────────────────┐│
│  │     Docker Compose Environment      ││
│  │  ┌─────────┐ ┌─────────┐ ┌───────┐ ││
│  │  │Frontend │ │Services │ │Infra  │ ││
│  │  └─────────┘ └─────────┘ └───────┘ ││
│  └─────────────────────────────────────┘│
└─────────────────────────────────────────┘

Best for: Individual developers, local testing, demos

Single-Cluster Lab

A containerized deployment on a single Kubernetes cluster:

┌─────────────────────────────────────────────────────────────┐
│                    Kubernetes Cluster                        │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐│
│  │ Frontend  │  │ Services  │  │ Database  │  │ Monitoring││
│  │   Pod     │  │   Pods    │  │   Pod     │  │   Pods    ││
│  └───────────┘  └───────────┘  └───────────┘  └───────────┘│
└─────────────────────────────────────────────────────────────┘

Best for: Small teams, staging environments, proof-of-concept

Multi-Cluster Production

For production workloads, Inwire can span multiple Kubernetes clusters with managed services:

┌─────────────────────────────────────────────────────────────────────────────┐
│                         Production Environment                               │
│                                                                              │
│  ┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐           │
│  │  Control Plane  │   │  Worker Cluster │   │  Worker Cluster │           │
│  │    Cluster      │   │    (Region A)   │   │    (Region B)   │           │
│  │  ┌───────────┐  │   │  ┌───────────┐  │   │  ┌───────────┐  │           │
│  │  │ Core/API  │  │   │  │ Training  │  │   │  │ Training  │  │           │
│  │  │ Services  │  │   │  │  Workers  │  │   │  │  Workers  │  │           │
│  │  └───────────┘  │   │  └───────────┘  │   │  └───────────┘  │           │
│  └─────────────────┘   └─────────────────┘   └─────────────────┘           │
│                                                                              │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                    Managed Services                                  │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐│   │
│  │  │ PostgreSQL  │  │    Redis    │  │     S3      │  │ Monitoring  ││   │
│  │  │   (RDS)     │  │(ElastiCache)│  │   (Cloud)   │  │ (Managed)   ││   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘│   │
│  └─────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘

Best for: Enterprise deployments, high availability requirements, multi-region

Multi-Cloud / Hybrid

Inwire can orchestrate workloads across multiple cloud providers:

AWS — EKS, RDS, S3, SageMaker integration
GCP — GKE, Cloud SQL, GCS, Vertex AI integration
Azure — AKS, Azure Database, Blob Storage, Azure ML integration
On-Premises — Self-managed Kubernetes with local storage

Getting Started with Deployment

Prerequisites

Before deploying Inwire, ensure you have:

Docker (20.10+) and Docker Compose (v2.0+)
Git for cloning the repository
Node.js (18+) and pnpm for frontend development
Python (3.11+) for backend services
kubectl for Kubernetes deployments (optional)

Quick Start: Local Development

Clone the Repository

```bash

git clone https://github.com/your-org/inwire-platform.git

cd inwire-platform

```

Configure Environment

Copy the example environment file and adjust settings:

```bash

cp .env.example .env

```

Key variables to configure:

- DATABASE_URL — PostgreSQL connection string

- REDIS_URL — Redis connection string

- JWT_SECRET — Secret key for JWT tokens

- S3_ENDPOINT, S3_ACCESS_KEY, S3_SECRET_KEY — Object storage credentials

Start Infrastructure

```bash

cd infra/compose

docker-compose up -d

```

This starts PostgreSQL, Redis, and other infrastructure components.

Start Backend Services

Each service can be started individually:

```bash

# In separate terminals

cd services/core && uvicorn main:app --reload --port 18000

cd services/synthex && uvicorn main:app --reload --port 18090

cd services/model-training && uvicorn main:app --reload --port 18052

```

Start Frontend

```bash

cd frontend

pnpm install

pnpm dev

```

The frontend will be available at http://localhost:3000.

Kubernetes Deployment

For Kubernetes deployments, Inwire provides:

Helm Charts — Configurable deployment templates
Kustomize Overlays — Environment-specific configurations
ArgoCD Support — GitOps-based continuous deployment

> Note: Detailed Kubernetes deployment instructions are available in the infra/k8s/ directory of the repository.

Configuration

Service Configuration

Each backend service is configured through environment variables:

Variable	Description	Example
`DATABASE_URL`	PostgreSQL connection	`postgresql+asyncpg://user:pass@localhost/db`
`REDIS_URL`	Redis connection	`redis://localhost:6379/0`
`JWT_SECRET`	JWT signing key	`your-secret-key`
`LOG_LEVEL`	Logging verbosity	`INFO`, `DEBUG`, `WARNING`
`CORS_ORIGINS`	Allowed CORS origins	`http://localhost:3000`

Frontend Configuration

The frontend uses environment variables prefixed with NEXT_PUBLIC_:

Variable	Description	Example
`NEXT_PUBLIC_CORE_API_URL`	Core API endpoint	`http://localhost:18000`
`NEXT_PUBLIC_SYNTHEX_API_URL`	Synthex API endpoint	`http://localhost:18090`
`NEXT_PUBLIC_MODEL_TRAINING_API_URL`	Model Training API	`http://localhost:18052`

Health Checks

Each service exposes health check endpoints:

Endpoint	Description
`/health`	Basic liveness check
`/health/ready`	Readiness check (includes dependencies)

Example:

curl http://localhost:18090/health
# {"status": "healthy", "version": "2.0.0"}

Next Steps

Once Inwire is deployed:

Getting Started — Log in and explore the platform
Setting up Inwire — Configure your organization
Using Inwire — Learn day-to-day workflows

Troubleshooting

Common Issues

Services won't start:

Check that PostgreSQL and Redis are running
Verify environment variables are set correctly
Check service logs: docker-compose logs <service-name>

Database connection errors:

Ensure PostgreSQL is accepting connections
Verify the database user has appropriate permissions
Check that the database schema exists

Frontend can't reach backend:

Verify backend services are running and accessible
Check CORS configuration allows the frontend origin
Ensure NEXT_PUBLIC_* environment variables are set

For additional help, consult the troubleshooting guide or contact your platform administrator.