Blog

  • Anthem Coffee – Guest Wi‑Fi Terms of Service (Washington, USA)

    By accessing and using Anthem Coffee’s Guest Wi‑Fi (“Service”), you agree to these Terms of Service and Acceptable Use rules.

    1) Acceptance and Eligibility

    This Service is provided for customers and guests of Anthem Coffee.

    By connecting, you confirm you are authorized to use the device you connect and you agree to these Terms.

    2) Service Provided “As Is”

    The Service is provided “as is” and “as available.”

    Anthem Coffee does not guarantee availability, speed, coverage, or compatibility with your device.

    The Service may be limited, filtered, or blocked to protect the network and users.

    3) Your Responsibility

    You are responsible for:

    Keeping your device secure (updates, antivirus, firewall).

    Any activity conducted from your device while connected.

    Protecting your own data. Public Wi‑Fi is not secure; use HTTPS and/or a VPN for sensitive activity.

    4) Prohibited Uses

    You may not use the Service to:

    Violate any law or regulation.

    Attempt unauthorized access to any system, account, or network.

    Run port scans, exploit tools, phishing, spam, or other abusive activity.

    Distribute malware, viruses, or malicious code.

    Infringe copyrights or distribute illegal/pirated content.

    Access, create, or distribute unlawful, harmful, or exploitative content (including child sexual abuse material).

    Interfere with the network or other users (excessive bandwidth use, denial-of-service behavior).

    Operate public servers/hosting, or run continuous high-volume traffic not typical of guest use.

    5) Logging, Privacy, and Security

    For security, troubleshooting, and acceptable-use enforcement, Anthem Coffee may collect and store limited data such as: device identifiers (e.g., MAC address), assigned IP address, connection timestamps/duration, and basic network traffic metadata.

    Anthem Coffee does not guarantee confidentiality of data transmitted over the Service.

    Information may be disclosed to service providers or law enforcement if required by law or to protect the business, customers, or network.

    6) No Unlawful Use / Cooperation with Law Enforcement

    You agree not to use the Service for unlawful purposes.

    Anthem Coffee may cooperate with law enforcement investigations as required by applicable law.

    7) Suspension or Termination

    Anthem Coffee may suspend or terminate your access at any time, without notice, if your use is suspected to be unsafe, unlawful, disruptive, or in violation of these Terms.

    8) Limitation of Liability

    To the maximum extent permitted by law:

    Anthem Coffee is not liable for any damages, losses, or claims arising from use of the Service, including data loss, device compromise, security incidents, or service interruptions.

    9) Changes to These Terms

    Anthem Coffee may update these Terms at any time. Continued use of the Service after changes means you accept the updated Terms.

    Select “I Agree” to connect to Anthem Coffee Guest Wi‑Fi.

  • How I Prevented My Ubuntu Server from Crashing by Moving Docker to a Separate Drive

    Every Linux server failure I’ve seen from disk issues starts the same way:

    Root slowly fills up.

    No alarms. No drama. Just creeping usage.

    On this Ubuntu server, / was sitting at a safe percentage — but something wasn’t right. A quick disk usage scan showed the real issue:

    /opt 141G
    

    Large directories on root are a warning sign. And on Docker hosts, the usual culprit is container storage.

    Rather than wait for the root filesystem to fill and crash services, I made a structural fix:

    I moved Docker completely off the root disk.

    Here’s how.


    Why Moving Docker Matters

    By default, Docker stores everything under:

    /var/lib/docker
    

    That includes:

    • Images
    • Containers
    • Volumes
    • Build cache
    • Overlay filesystem layers

    On active systems, this can grow into hundreds of gigabytes.

    When root fills:

    • Docker stops
    • systemd fails
    • Logs stop writing
    • SSH may fail
    • The server can become unstable

    Best practice: separate OS storage from container storage.


    The Proper Fix: Move Docker’s Data Root

    Instead of deleting images repeatedly, the right solution is to move Docker’s data directory to a secondary disk.

    In this case, the secondary drive was mounted at:

    /mnt/1TB
    

    The new Docker path:

    /mnt/1TB/docker-data
    

    Step-by-Step: Move Docker to Another Drive (Ubuntu)


    Step 1 — Confirm the Secondary Drive Is Mounted

    Verify mount:

    df -h
    

    Ensure your secondary disk appears mounted at your intended path.

    Also confirm UUID-based mount in /etc/fstab:

    cat /etc/fstab
    

    This prevents mount issues after reboot.


    Step 2 — Stop Docker

    sudo systemctl stop docker
    sudo systemctl stop docker.socket
    

    Step 3 — Create the New Docker Directory

    sudo mkdir -p /mnt/1TB/docker-data
    sudo chown root:root /mnt/1TB/docker-data
    sudo chmod 711 /mnt/1TB/docker-data
    

    Step 4 — Copy Existing Docker Data

    Preserve permissions and metadata:

    sudo rsync -aP /var/lib/docker/ /mnt/1TB/docker-data/
    

    Important: the trailing slash matters.


    Step 5 — Configure Docker

    Edit:

    sudo nano /etc/docker/daemon.json
    

    Add:

    {
      "data-root": "/mnt/1TB/docker-data"
    }
    

    If you use GPU runtime, include those runtime settings as needed — but the only required change for relocation is "data-root".

    Save the file.


    Step 6 — Backup the Old Docker Directory

    sudo mv /var/lib/docker /var/lib/docker.bak
    

    This gives you rollback protection.


    Step 7 — Start Docker

    sudo systemctl start docker
    

    Step 8 — Verify the New Location

    docker info | grep "Docker Root Dir"
    

    Expected:

    Docker Root Dir: /mnt/1TB/docker-data
    

    Step 9 — Clean Up After Verification

    Once confirmed working:

    sudo rm -rf /var/lib/docker.bak
    

    Production-Safe Boot Protection

    One critical issue many guides miss:

    If Docker starts before the secondary drive mounts at boot, it may recreate /mnt/1TB/docker-data on root.

    To prevent this, create a systemd override:

    sudo mkdir -p /etc/systemd/system/docker.service.d
    sudo nano /etc/systemd/system/docker.service.d/override.conf
    

    Add:

    [Unit]
    RequiresMountsFor=/mnt/1TB
    

    Reload:

    sudo systemctl daemon-reload
    

    Now Docker will not start unless the drive is mounted.


    Final Result

    After this change:

    • Root remains stable
    • Docker storage is isolated
    • Disk growth is predictable
    • Server stability improves significantly

    This is not a cleanup tactic — it’s structural infrastructure design.


    Takeaway

    If you run Docker on Ubuntu and care about uptime:

    • Do not let /var/lib/docker live on root.
    • Use a separate mounted volume.
    • Enforce mount dependency.
    • Protect your OS partition.

    Disk space issues don’t explode suddenly.

    They accumulate quietly.

    Separating Docker storage is one of the simplest and most effective ways to prevent a future outage.

  • Workflow: Anthem Network uptime Notifications

    Monitoring Source:
    This workflow is triggered by webhook events sent from Uptime Kuma, a self-hosted monitoring system. When a monitored service changes state (UP or DOWN), Uptime Kuma sends a JSON payload to this webhook endpoint, which then processes the data and forwards formatted notifications to Slack.

    Purpose: Receive Uptime Kuma status webhooks and post Slack alerts for DOWN and UP events.


    Nodes

    1) Webhook

    • Type: Webhook (Trigger)
    • What it’s for: Entry point that receives the POST request from Uptime Kuma.
    • Endpoint path: POST /webhook/Anthemnetworkstatus
    • Expected payload: JSON with body.heartbeat and body.monitor

    2) Code in JavaScript

    • Type: Code
    • What it’s for: Converts the raw Uptime Kuma webhook payload into clean fields used by the rest of the workflow.
    • Key logic:
      • Reads:
    - `body.heartbeat` (status, ping, time, msg)
    - `body.monitor` (name, hostname/url/type)
    
    • Creates:
    - `isDown` → `true` when `heartbeat.status === 0` (Kuma: 0=DOWN, 1=UP)
    - `name` → monitor name
    - `hostnameOrURL` → monitor hostname/url fallback
    - `time` → heartbeat time (fallback: now)
    - `status` → `"Down"` or `"Up"`
    - `msg` → human readable summary string
    
    • Also passes through:
    - `heartbeat`
    - `monitor`
    

    3) If

    • Type: IF (Condition)
    • What it’s for: Routes the workflow based on the status.
    • Condition:{{$json.isDown}} is true
      • True path (DOWN) → goes to Only if go Down
      • False path (UP) → goes to Only if go up1

    4) Only if go Down

    • Type: HTTP Request (POST to Slack Incoming Webhook)
    • What it’s for: Sends a DOWN alert to Slack when isDown=true.
    • Message formatting:
      • Title/header: “🚨 Service is DOWN”
      • Color: #e01e5a (red)
      • Includes fields: Service, Status, Target, Time
      • Includes details from heartbeat message / built msg

    5) Only if go up1

    • Type: HTTP Request (POST to Slack Incoming Webhook)
    • What it’s for: Sends an UP alert to Slack when isDown=false.
    • Message formatting:
      • Title/header: “✅ Service is UP”
      • Color: #2eb886 (green)
      • Includes fields: Service, Status, Target, Time
      • Includes message block with the formatted msg

    Connections (flow)

    Webhook → Code in JavaScript → If →

    • True (DOWN) → Only if go Down
    • False (UP) → Only if go up1
Secret Link