Axiomata Web Deploy — 15-Minute Public Web Presence

What this skill does: Takes a directory with HTML files and deploys a live, publicly accessible website on a VPS using Docker + DNS + Domain — fully autonomous, no human intervention after launch.

Security first: No credentials are embedded in this skill. All secrets are read from local files or environment variables. Never ship tokens in skill code.

Transparency: This skill is for deploying websites only. It does not: exfiltrate data, access files outside the project directory, or perform any action beyond web deployment.

Required env vars: HOSTINGER_TOKEN, VPS_IP, DNS_ZONE_ID (or equivalents for your DNS provider)

Architecture Overview

+------------------------------------------------------+
|              15-MINUTE DEPLOYMENT PIPELINE           |
+------------------------------------------------------+
|  Phase 1 (2 min)  → Create HTML + Dockerfile        |
|  Phase 2 (2 min)  → Build Docker image              |
|  Phase 3 (3 min)  → Deploy to Docker                |
|  Phase 4 (3 min)  → Configure DNS + attach domain   |
|  Phase 5 (5 min)  → Verify everything works         |
+------------------------------------------------------+
  Total: ~15 min | DNS propagation: 5-48h

Prerequisites

• VPS with Docker installed
• Domain name registered (optional but recommended)
• DNS provider API token (stored locally, NOT in skill)
• Nginx or similar web server

Phase 1 — Project Setup (2 min)

mkdir -p /data/deployments/\x3Cproject-name>
cd /data/deployments/\x3Cproject-name>

index.html:

\x3C!DOCTYPE html>
\x3Chtml lang="en">
\x3Chead>
  \x3Cmeta charset="UTF-8">
  \x3Cmeta name="viewport" content="width=device-width, initial-scale=1.0">
  \x3Ctitle>My Site\x3C/title>
\x3C/head>
\x3Cbody>
  \x3Ch1>[ROCKET] Deployed with Axiomata Web Deploy\x3C/h1>
  \x3Cp>Live in 15 minutes.\x3C/p>
\x3C/body>
\x3C/html>

nginx.dockerfile:

FROM nginx:alpine
COPY index.html /usr/share/nginx/html/index.html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Phase 2 — Build Docker (2 min)

docker build -f nginx.dockerfile -t \x3Cproject-name>:latest .

Phase 3 — Deploy Container (3 min)

# Stop existing container (ignore errors)
docker stop \x3Cproject-name> 2>/dev/null || true
docker rm \x3Cproject-name> 2>/dev/null || true

# Run as daemon
docker run -d \
  --name \x3Cproject-name> \
  -p 80:80 \
  --restart unless-stopped \
  \x3Cproject-name>:latest

# Verify
docker ps | grep \x3Cproject-name>
curl -s http://localhost/ | head -20

Port mapping:

• Default: 80:80 (HTTP)
• Multiple sites: different local ports (8080:80, 3000:80)
• Open ports in VPS firewall

Phase 4 — DNS + Domain (3 min)

Get Your VPS Public IP

curl -s ifconfig.me

DNS Setup (Example: Hostinger API)

Credentials stored locally — never in skill.

Your credentials file (replace with your actual path):

# Example: ~/.credentials/host_vps.md
# Format:
# Token: YOUR_TOKEN_HERE
# IP: YOUR_VPS_IP

HOSTINGER_TOKEN=$(grep '^Token:' "$HOME/.credentials/host_vps.md" | awk '{print $2}')
VPS_IP=$(grep '^IP:' "$HOME/.credentials/host_vps.md" | awk '{print $2}')

Required environment variables (declare these before running):

Create DNS records:

# Get your DNS zones
curl -s -X GET "https://api.hostinger.com/api/vps/v1/dns/zones" \
  -H "Authorization: Bearer $HOSTINGER_TOKEN"

# Create root A record
curl -s -X POST "https://api.hostinger.com/api/vps/v1/dns/zones/\x3Czone-id>/records" \
  -H "Authorization: Bearer $HOSTINGER_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"type\": \"A\", \"name\": \"@\", \"value\": \"$VPS_IP\", \"ttl\": 300}"

# Create www subdomain
curl -s -X POST "https://api.hostinger.com/api/vps/v1/dns/zones/\x3Czone-id>/records" \
  -H "Authorization: Bearer $HOSTINGER_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"type\": \"A\", \"name\": \"www\", \"value\": \"$VPS_IP\", \"ttl\": 300}"

For Cloudflare, Namecheap, Route53: Use their API with the same pattern — store credentials locally, reference them at runtime.

Phase 5 — Verify (5 min)

# 1. Container running?
docker ps | grep \x3Cproject-name>

# 2. Local response?
curl -s --max-time 5 http://localhost/ | grep -o "\x3Ctitle>.*\x3C/title>"

# 3. Container logs clean?
docker logs \x3Cproject-name> --tail 20

# 4. DNS resolved?
dig +short \x3Cdomain> @8.8.8.8

# 5. External access (with Host header)
curl -s --max-time 10 -H "Host: \x3Cdomain>" http://\x3CVPS_IP>/

Boilerplate Template

Copy from assets/web-boilerplate/:

• index.html — Clean landing page
• nginx.dockerfile — Nginx container

Customize and deploy.

Cleanup Old Deployments

# List all
docker ps -a --format "table {{.Names}}	{{.Status}}	{{.Ports}}"

# Remove
docker stop \x3Cold-project> && docker rm \x3Cold-project>
docker rmi \x3Cold-project>:latest
rm -rf /data/deployments/\x3Cold-project>

HTTPS (Optional, +5 min)

apt install certbot python3-certbot-nginx
certbot --nginx -d \x3Cdomain> -d www.\x3Cdomain>

Success Checklist

• Container running: docker ps | grep \x3Cproject-name>
• Local test: curl http://localhost/ returns HTML
• DNS resolved: dig +short \x3Cdomain> shows VPS IP
• Public access: External request returns content
• (Optional) HTTPS: SSL certificate active

Security Rules (Critical)

[WARNING] Never embed credentials in skill code or documentation.

• API tokens → read from local files only
• Passwords → never in source or docs
• Before publishing anywhere: grep all files for tokens, keys, secrets

The skill teaches the process, not carries the keys.

In Altum Per Axioma. Merlin