If you see this page, your container and security group are configured correctly.
``` Create `Dockerfile`: ```dockerfile FROM nginx:alpine COPY index.html /usr/share/nginx/html/index.html ``` `nginx:alpine` is a small image with a production-grade web server, which keeps pull and build times short. ## Step 5: Build the image The build reads the Dockerfile and produces a local image tag we can run. ```bash docker build -t YOUR_IMAGE_NAME . ``` Use a meaningful tag (for example `rumble-static-demo:latest`) in place of `YOUR_IMAGE_NAME`. ## Step 6: Run the container We publish container port 80 to the host's port 80 so traffic that reaches the VM on port 80 (allowed by the security group) reaches nginx. ```bash docker run -d --name YOUR_CONTAINER_NAME -p 80:80 YOUR_IMAGE_NAME ``` Replace `YOUR_CONTAINER_NAME` with a unique name such as `static-web`. On the Developer Plan, always pass `--memory` and `--memory-swap` so a runaway container cannot consume all available RAM: ```bash docker run -d --name YOUR_CONTAINER_NAME \ --memory=256m --memory-swap=512m \ -p 80:80 YOUR_IMAGE_NAME ``` Use Alpine-based images (`nginx:alpine`, `node:22-alpine`, `python:3.12-alpine`). They are 5–10× smaller than full images and pull faster. ## Step 7: Test locally on the instance `curl` checks the stack from the server itself before we involve the public network path. ```bash curl -sS http://127.0.0.1/ | head -n 5 ``` You should see the HTML title or heading from `index.html`. If the command hangs or fails, run `docker ps` and `docker logs YOUR_CONTAINER_NAME` to confirm the container is running. ## Step 8: Reach the app from the internet From your **local** terminal (not inside SSH), request the instance public IP: ```bash curl -sS http://YOUR_INSTANCE_IP/ | head -n 5 ``` If this fails but Step 7 passed, verify the security group allows ingress on port 80 (and that no host firewall blocks port 80). ## Step 9: Verify in a browser Open `http://YOUR_INSTANCE_IP` in a desktop or mobile browser. You should see the demo heading and paragraph. Browsers follow redirects and cache behavior differently than `curl`, so this step confirms real user traffic works. ## Multi-service stacks with Docker Compose (optional) Once your single-container app works, you can compose multiple services. Create `~/compose-demo/compose.yaml` with explicit memory limits: ```bash mkdir -p ~/compose-demo && cd ~/compose-demo cat > compose.yaml <<'EOF' services: app: image: node:22-alpine working_dir: /app volumes: - ./app:/app ports: - "3000:3000" command: ["node", "server.js"] deploy: resources: limits: memory: 256M redis: image: redis:7-alpine ports: - "6379:6379" deploy: resources: limits: memory: 64M EOF ``` Add a minimal Node.js entry point: ```bash mkdir -p app cat > app/server.js <<'EOF' const http = require("http"); const server = http.createServer((req, res) => { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ status: "ok", container: true })); }); server.listen(3000, () => console.log("Listening on :3000")); EOF ``` Bring the stack up: ```bash docker compose up -d docker compose ps curl http://localhost:3000 ``` On the Developer Plan, `docker stats` shows real-time memory consumption per container, useful when tuning limits. ## Resource management tips On any small tier, memory is the primary constraint. Apply these practices: - **Always set `--memory` limits** on containers to prevent runaway usage. - **Use Alpine-based images** when available. They are 5–10× smaller than full images. - **Run one service at a time** during development instead of a full stack. - **Monitor usage** with `docker stats` to watch real-time memory per container. - **Clean up on a schedule**: stopped containers and unused images consume disk: ```bash docker system prune -f docker image prune -a -f ``` ## Cloud-init for zero-touch Docker setup (optional) To launch a VM with Docker and swap pre-configured, pass this cloud-init script as `--user-data` on `openstack server create`: ```yaml #cloud-config package_update: true write_files: - path: /etc/sysctl.d/99-swap.conf content: | vm.swappiness=60 runcmd: - fallocate -l 1G /swapfile - chmod 600 /swapfile - mkswap /swapfile - swapon /swapfile - echo '/swapfile none swap sw 0 0' >> /etc/fstab - apt-get update - apt-get install -y ca-certificates curl - install -m 0755 -d /etc/apt/keyrings - curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc - chmod a+r /etc/apt/keyrings/docker.asc - echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" > /etc/apt/sources.list.d/docker.list - apt-get update - apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin - usermod -aG docker ubuntu ``` Cloud-init runs at first boot, so the instance reaches `ACTIVE` with Docker already installed. ## What you learned In this tutorial, we: - **Configured security groups** so SSH and HTTP reach the instance through explicit rules - **Installed Docker** using the official repository on Ubuntu 24.04 - **Built an image** from a Dockerfile that layers static content on `nginx:alpine` - **Ran a container** with port publishing so host port 80 maps to the web server - **Validated** the deployment with `curl` and a browser through `YOUR_INSTANCE_IP` ## Next steps - [How to point a domain at a Quake AI resource](/docs/network/how-to/point-domain-to-quake-ai): replace the instance public IP in the browser bar with your own hostname - [How to issue and auto-renew a TLS certificate with Let's Encrypt](/docs/network/how-to/lets-encrypt-certificate): HTTPS for the container on port 80 - [How to deploy an application to a Quake AI VM from CI](/docs/automation/how-to/app-cicd-vm): automate image build and deploy from GitHub Actions or GitLab CI - [How to use a container registry with Quake AI](/docs/kubernetes/how-to/use-container-registry): push images to GHCR, Docker Hub, or another registry the VM can pull from - [How to store application secrets and inject them at runtime](/docs/security/how-to/inject-app-secrets): registry tokens and app config without baking secrets into images - Read [Docker overview](https://docs.docker.com/get-started/overview/) and [Dockerfile reference](https://docs.docker.com/reference/dockerfile/) for deeper container workflows - Explore Quake AI compute concepts: [Instances](/docs/compute/concepts/instances), [Images](/docs/compute/concepts/images), and [Flavors](/docs/compute/concepts/flavors) - Harden exposure with [Security groups](/docs/network/concepts/security-groups) and the [Security hardening checklist](/docs/security/hardening-checklist) - [Resource tiers](/docs/account/resource-tiers): plan your upgrade path if your stack outgrows the Developer Plan ## Clean up When you no longer need the demo: 1. **On the instance (SSH):** stop and remove the container: ```bash docker stop YOUR_CONTAINER_NAME docker rm YOUR_CONTAINER_NAME ``` 2. **In the console:** delete the instance at **Compute** > **Instances** to stop compute charges. The `PublicEphemeral` public IP is released with the instance, so there is no floating IP to release. 3. **Optional:** remove the `tutorial-web` security group if you created it for this walkthrough.