AI Agent Integration

Install UltraBalancer load balancer on Ubuntu 22.04 server:

1. Install Rust toolchain and dependencies
2. Clone https://github.com/bas3line/ultrabalancer.git  
3. Build with cargo build --release
4. Install to /usr/local/bin/ultrabalancer
5. Verify with ultrabalancer --version

Please execute these commands and show me the output.

Create a UltraBalancer configuration file at /etc/ultrabalancer/config.yaml:

- Listen on port 80
- Backend servers: 192.168.1.10:8080, 192.168.1.11:8080, 192.168.1.12:8080
- Use round-robin algorithm
- Enable health checks every 5 seconds
- Maximum 3 failures before marking server down

Generate the complete YAML configuration file.

Create a systemd service for UltraBalancer:

1. Create service file at /etc/systemd/system/ultrabalancer.service
2. Run as user 'ultrabalancer'
3. Use config file /etc/ultrabalancer/config.yaml
4. Auto-restart on failure
5. Enable on boot
6. Start the service and show status

Execute all steps.

Create a Docker Compose setup for UltraBalancer:

1. Use image: ghcr.io/bas3line/ultrabalancer:latest
2. Map port 80 to container port 8080
3. Mount config.yaml file
4. Include 3 nginx backend containers
5. Create custom network
6. Start with docker-compose up -d

Generate the docker-compose.yml file and start the services.

Create Kubernetes manifests for UltraBalancer:

1. ConfigMap with configuration
2. Deployment with 2 replicas  
3. Service (LoadBalancer type)
4. Health check probes
5. Apply all manifests

Generate all YAML files and apply to cluster.

Test UltraBalancer is working:

1. Check health endpoint: curl localhost/health
2. Check metrics: curl localhost/metrics  
3. Send 10 test requests
4. Verify requests are distributed across backends

Show all outputs.

Test UltraBalancer failover:

1. Check current health status
2. Kill one backend server
3. Wait 10 seconds
4. Check health status again (should show degraded)
5. Send 10 requests (should only go to healthy backends)
6. Restart the backend
7. Verify it recovers

Show all outputs and verify failover works.

Performance test UltraBalancer:

1. Install Apache Bench (ab)
2. Run: ab -n 10000 -c 100 http://localhost/
3. Check metrics endpoint
4. Report: requests/sec, response time, failures

Show results and analysis.

Deploy UltraBalancer on Ubuntu 22.04 production server:

Repository: https://github.com/bas3line/ultrabalancer

Requirements:
- Build from source using Rust/Cargo
- Install to /usr/local/bin
- Config: /etc/ultrabalancer/config.yaml
- Listen on port 80
- Backends: 10.0.1.10:8080 (weight 200), 10.0.1.11:8080 (weight 100)
- Use least-connections algorithm
- Health checks every 5 seconds
- Run as systemd service
- Start on boot
- Run as unprivileged user

Steps:
1. Install dependencies
2. Build and install
3. Create user and directories
4. Create configuration
5. Create systemd service
6. Configure firewall
7. Start and verify

Show output of: ultrabalancer --version, curl localhost/health, curl localhost/metrics