Vissa webbplatser släpper inte in besökare från EU. Ett vanligt VPN-abonnemang löser det, men kostar varje månad även när du bara behöver det några timmar. Jag byggde i stället en egen VPN-server i USA som inte finns förrän jag ber om den. Den startar med ett tryck på mobilen, stänger av sig själv när jag är klar och kostar i praktiken bara några cent i månaden.

I det här inlägget går jag igenom hur upplägget fungerar, vad som krävs, vad det kostar och varför det inte är rätt verktyg för streaming.

Faktaruta

Förutsättningar

• Ett AWS-konto och vana vid att klicka runt i konsolen. Du behöver kunna skapa en EC2-instans, en Lambda-funktion och en IAM-policy.
• En domän med DNS hos Cloudflare, och en API-token som bara får redigera DNS i den zonen (så skapar du en token).
• WireGuard-appen på telefonen och en genväg som anropar din funktion. På iPhone gör du det med Genvägar.
• Grundläggande Linux-kunskap för att installera WireGuard och ställa in IP-vidarebefordran på servern.
• Ett budgetlarm i AWS. Gör det innan du bygger, inte efteråt (mer om det nedan).

Räkna med ett par timmar första gången. Därefter är det bara att använda.

Så fungerar det

1. Du trycker på en genväg i telefonen. Den anropar en Lambda-funktion via en funktions-URL och skickar med en hemlig token i en header. Utan token svarar funktionen med ett fel.
2. Funktionen startar en server från en färdig avbild (AMI) med WireGuard redan installerat och konfigurerat. Finns det redan en körande server återanvänds den i stället för att en ny skapas.
3. Funktionen väntar på serverns IP-adress och uppdaterar en DNS-post hos Cloudflare, så att din telefon alltid hittar rätt adress via ett vanligt hostnamn.
4. Du slår på tunneln i WireGuard-appen. All trafik går nu ut via USA.
5. Servern stänger av sig själv. Ett litet script kontrollerar var femte minut när tunneln senast hade kontakt. Efter 30 minuter utan kontakt, eller efter åtta timmar som längst, stängs servern ner och raderas helt, inklusive disken.

Eftersom servern raderas varje gång finns det ingenting som kostar mellan användningstillfällena, förutom avbilden den startas från.

Kostnadsmedvetenhet: därför blir det så billigt (och hur du håller det så)

AWS tar betalt för tid, lagring och utgående datatrafik. Så här ser det ut i det här upplägget:

Sätt dessa skyddsnät på plats så att ett misstag inte blir dyrt:

• Se till att servern verkligen försvinner. Ställ in att den ska termineras (inte bara stoppas) när den stängs av, annars blir disken kvar och kostar.
• Begränsa antalet samtidiga körningar av funktionen till 1. Då kan en läckt URL inte starta en hel flotta av servrar.
• Sätt ett tak på körtiden. Mitt avstängningsscript stänger alltid servern efter åtta timmar, även om tunneln fortfarande är på.
• Ge funktionen minimala rättigheter. Den behöver kunna starta och lista servrar, men inte radera eller ändra något annat.
• Använd AWS Budgets för att få ett mejl när kostnaderna närmar sig en gräns. Budgetar uppdateras några gånger per dygn, så de är ett skyddsnät och inget larm i realtid.
• Kontrollera efter första testerna att inga instanser, lösa diskar eller reserverade IP-adresser ligger kvar.

Varför det här inte är lämpligt för streaming

Det här är en lösning för att surfa, logga in och nå sidor, inte för att titta på film. Det finns två skäl, och det första är kostnaden.

1. Trafikkostnaden äter upp allt. När du laddar ner något via VPN:en räknas det som utgående trafik från AWS. De första 100 GB per månad ingår, men streaming förbrukar dem snabbt. Enligt Netflix går det åt ungefär 3 GB per timme i HD och upp till cirka 7 GB per timme i 4K. Det ger:

• 100 GB räcker till ungefär 33 timmar HD eller 14 timmar 4K, och då har du inte gjort något annat.
• Därefter kostar trafiken ungefär 0,09 USD/GB, alltså runt 0,27 USD per timme HD-streaming.
• Själva servern kostar cirka 0,01 USD per timme. Trafiken blir alltså ungefär 30 gånger dyrare än servern, och det är den som avgör räkningen.

I ett upplägg som är byggt för att kosta några cent är det inte vettigt att bränna trafikbudgeten på film. Ett vanligt VPN-abonnemang med fast pris är då både enklare och billigare.

2. Streamingtjänster blockerar ofta datacenter-adresser. Adresser från molnleverantörer som AWS känns igen och stängs ofta ute, oavsett vilket land de ligger i. Du kan alltså betala för trafiken och ändå inte komma in. Samma sak gäller en del banker och nyhetstjänster.

Gott att veta

• Det hjälper mot enkla geospärrar, inte mot sidor som blockerar hela datacenter-intervall. Då hjälper ingen molnleverantör, bara en bostadsadress.
• Läs villkoren för de tjänster du använder. Att kringgå en geospärr kan strida mot en tjänsts användarvillkor.
• Ingen SSH-åtkomst är ett medvetet val. Servern har ingen inloggning alls, vilket minskar angreppsytan. Vill du uppdatera den bygger du en ny avbild.
• Det är ditt ansvar att hålla avbilden uppdaterad. Planera in en ny avbild då och då, till exempel några gånger per år.

Steg för steg: så sätter du upp det själv

chmod 400 ~/Downloads/wg-base-key.pem
ssh -i ~/Downloads/wg-base-key.pem ubuntu@<INSTANSENS-PUBLIKA-IP>

sudo apt update && sudo apt install -y wireguard qrencode
command -v iptables || sudo apt install -y iptables
sudo -i

umask 077
mkdir -p /etc/wireguard && cd /etc/wireguard
wg genkey | tee server.key | wg pubkey > server.pub
wg genkey | tee client.key | wg pubkey > client.pub
wg genpsk > psk.key
ls -l
wc -c server.key server.pub client.key client.pub psk.key

echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/99-wireguard.conf
sysctl --system | grep ip_forward
cat > /etc/wireguard/wg0.conf <<EOF
[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = $(cat /etc/wireguard/server.key)
PostUp = iptables -t nat -A POSTROUTING -s 10.8.0.0/24 -o ens5 -j MASQUERADE
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT
PostUp = iptables -A FORWARD -o wg0 -m state --state RELATED,ESTABLISHED -j ACCEPT
PostDown = iptables -t nat -D POSTROUTING -s 10.8.0.0/24 -o ens5 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT
PostDown = iptables -D FORWARD -o wg0 -m state --state RELATED,ESTABLISHED -j ACCEPT
[Peer]
PublicKey = $(cat /etc/wireguard/client.pub)
PresharedKey = $(cat /etc/wireguard/psk.key)
AllowedIPs = 10.8.0.2/32
EOF
chmod 600 /etc/wireguard/wg0.conf
systemctl enable --now wg-quick@wg0
systemctl is-active wg-quick@wg0
wg show

cat > /etc/wireguard/client.conf <<EOF
[Interface]
PrivateKey = $(cat /etc/wireguard/client.key)
Address = 10.8.0.2/32
DNS = 1.1.1.1
[Peer]
PublicKey = $(cat /etc/wireguard/server.pub)
PresharedKey = $(cat /etc/wireguard/psk.key)
Endpoint = <INSTANSENS-PUBLIKA-IP>:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25
EOF
chmod 600 /etc/wireguard/client.conf
qrencode -t ansiutf8 < /etc/wireguard/client.conf

shred -u /etc/wireguard/client.key /etc/wireguard/client.conf
ls -l /etc/wireguard/

cat > /usr/local/bin/wg-idle.sh <<'EOF'
#!/bin/bash
IDLE_MAX=1800     # 30 min utan handshake
UP_MAX=28800      # hårt tak: 8 timmar
GRACE=900         # 15 min respit efter boot
NOW=$(date +%s)
UP=$(cut -d. -f1 /proc/uptime)
if [ "$UP" -gt "$UP_MAX" ]; then
  logger -t wg-idle "max uptime reached, shutting down"
  /sbin/shutdown -h now
  exit 0
fi
[ "$UP" -lt "$GRACE" ] && exit 0
LAST=$(wg show wg0 latest-handshakes | awk '{print $2}' | sort -n | tail -1)
if [ -z "$LAST" ] || [ "$LAST" -eq 0 ] || [ $((NOW-LAST)) -gt "$IDLE_MAX" ]; then
  logger -t wg-idle "idle, shutting down"
  /sbin/shutdown -h now
fi
EOF
chmod 700 /usr/local/bin/wg-idle.sh
cat > /etc/systemd/system/wg-idle.service <<'EOF'
[Unit]
Description=Shut down when WireGuard is idle
[Service]
Type=oneshot
ExecStart=/usr/local/bin/wg-idle.sh
EOF
cat > /etc/systemd/system/wg-idle.timer <<'EOF'
[Unit]
Description=Check WireGuard idle every 5 minutes
[Timer]
OnBootSec=5min
OnUnitActiveSec=5min
[Install]
WantedBy=timers.target
EOF
systemctl daemon-reload
systemctl enable --now wg-idle.timer
systemctl list-timers wg-idle.timer

rm -f /root/.bash_history /home/ubuntu/.bash_history
rm -f /home/ubuntu/.ssh/authorized_keys /root/.ssh/authorized_keys
cloud-init clean --logs
apt clean
history -c

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeInstances",
        "ec2:DescribeLaunchTemplateVersions"
      ],
      "Resource": "*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "ec2:RunInstances",
        "ec2:CreateTags"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": { "aws:RequestedRegion": "us-east-1" }
      }
    }
  ]
}

Koden. Ersätt innehållet i lambda_function.py och klicka Deploy. Funktionen kontrollerar token, startar en server (eller återanvänder en som redan körs), väntar på IP-adressen och uppdaterar DNS-posten hos Cloudflare. InvalidInstanceID.NotFound fångas och försöks om, eftersom EC2 ibland inte hittar en nystartad instans de första sekunderna. Koden visas i fyra kodblock nedan: klistra in dem efter varandra, i den ordningen, i samma fil.

import json
import os
import time
import urllib.request
import boto3
from botocore.exceptions import ClientError
ec2 = boto3.client("ec2", region_name="us-east-1")
SECRET = os.environ["SECRET"]
CF_TOKEN = os.environ["CF_TOKEN"]
CF_ZONE_ID = os.environ["CF_ZONE_ID"]
DNS_NAME = os.environ["DNS_NAME"]
SUBNET_ID = os.environ["SUBNET_ID"]
LT_ID = os.environ["LT_ID"]
def resp(code, body):
    return {
        "statusCode": code,
        "headers": {"Content-Type": "application/json"},
        "body": json.dumps(body),
    }

def find_instance():
    r = ec2.describe_instances(
        Filters=[
            {"Name": "tag:Name", "Values": ["wg-vpn"]},
            {"Name": "instance-state-name", "Values": ["pending", "running"]},
        ]
    )
    for res in r["Reservations"]:
        for i in res["Instances"]:
            return i["InstanceId"]
    return None
def start_instance():
    r = ec2.run_instances(
        LaunchTemplate={"LaunchTemplateId": LT_ID, "Version": "$Default"},
        SubnetId=SUBNET_ID,
        MinCount=1,
        MaxCount=1,
        TagSpecifications=[
            {"ResourceType": "instance", "Tags": [{"Key": "Name", "Value": "wg-vpn"}]}
        ],
    )
    return r["Instances"][0]["InstanceId"]

import threading
def pause(seconds):
    threading.Event().wait(seconds)
def wait_for_ip(instance_id, timeout=45):
    deadline = time.time() + timeout
    while True:
        if time.time() >= deadline:
            return None
        try:
            r = ec2.describe_instances(InstanceIds=[instance_id])
            ip = r["Reservations"][0]["Instances"][0].get("PublicIpAddress")
            if ip:
                return ip
        except ClientError as err:
            code = err.response["Error"]["Code"]
            if code != "InvalidInstanceID.NotFound":
                raise
        pause(2)

def cf(method, path, payload=None):
    req = urllib.request.Request(
        "https://api.cloudflare.com/client/v4" + path,
        data=json.dumps(payload).encode() if payload is not None else None,
        method=method,
        headers={
            "Authorization": "Bearer " + CF_TOKEN,
            "Content-Type": "application/json",
            "User-Agent": "wg-vpn-lambda/1.0",
        },
    )
    with urllib.request.urlopen(req, timeout=10) as f:
        return json.loads(f.read())
def update_dns(ip):
    r = cf("GET", f"/zones/{CF_ZONE_ID}/dns_records?type=A&name={DNS_NAME}")
    records = r.get("result", [])
    if not records:
        raise RuntimeError("DNS record " + DNS_NAME + " not found")
    rec_id = records[0]["id"]
    cf(
        "PUT",
        f"/zones/{CF_ZONE_ID}/dns_records/{rec_id}",
        {"type": "A", "name": DNS_NAME, "content": ip, "ttl": 60, "proxied": False},
    )
def lambda_handler(event, context):
    headers = {k.lower(): v for k, v in (event.get("headers") or {}).items()}
    if headers.get("x-token") != SECRET:
        return resp(403, {"error": "forbidden"})
    instance_id = find_instance()
    started = False
    if not instance_id:
        instance_id = start_instance()
        started = True
    ip = wait_for_ip(instance_id)
    if not ip:
        return resp(504, {"error": "no public ip yet", "instance": instance_id})
    update_dns(ip)
    return resp(
        200,
        {
            "status": "started" if started else "already running",
            "instance": instance_id,
            "ip": ip,
            "dns": DNS_NAME,
            "note": "wait ~45s, then turn on the tunnel",
        },
    )

# utan token: ska ge {"error": "forbidden"}
curl -s "https://<DIN-FUNCTION-URL>/"
# med token: startar en server och uppdaterar DNS (tar 10-20 sekunder)
curl -s -H "x-token: <SECRET>" "https://<DIN-FUNCTION-URL>/"
# kontrollera att DNS-posten fick serverns IP
dig +short vpn.exempel.se @1.1.1.1

Vanliga frågor

Hur mycket kostar en egen VPN på AWS?

Vid måttlig användning, runt 20 timmar i månaden, handlar det om cirka 0,3–0,5 USD i månaden. Den fasta delen är bara lagringen av serverns avbild, ungefär 0,1 USD.

Hur snabbt är den klar att använda?

Cirka 30–45 sekunder efter att du tryckt på genvägen, eftersom servern startar medan funktionen väntar på IP-adressen.

Vad händer om jag glömmer att stänga av tunneln?

Servern stängs ner efter högst åtta timmar, så en glömd tunnel kostar några cent och inte mer.

Går det att streama via den?

Tekniskt går det, men det rekommenderas inte. Trafikkostnaden blir ungefär 30 gånger högre än serverkostnaden, och många streamingtjänster blockerar ändå AWS-adresser.

Kan flera enheter dela samma VPN?

Ja, men varje enhet behöver en egen WireGuard-nyckel. Det byggs in i serverns avbild.

Sammanfattning

En VPN som bara finns när du behöver den är billig, enkel att kontrollera och inte beroende av ett abonnemang. Den passar bra för att surfa och logga in från USA. Håll koll på trafiken, sätt skyddsnäten på plats innan du börjar, och använd något annat om målet är att titta på film.

Priser och funktioner hos AWS och Cloudflare ändras. Kontrollera aktuella uppgifter hos leverantörerna innan du bygger.