Hosta FreshRSS på en Managed VPS: dina RSS-flöden på din egen server

Det FreshRSS gör

FreshRSS är en självhostad aggregator för RSS-flöden, skriven i PHP. README-filen beskriver den som lätt, enkel att arbeta med, kraftfull och anpassningsbar, översatt till fler än tjugo språk. Det är en applikation för flera användare, med ett anonymt läsläge och egna etiketter.

• Läsningen: dina prenumerationer sorterade i kategorier, etiketter, favoriter och sparade sökningar.
• WebSub: FreshRSS tar emot nya artiklar direkt från kompatibla källor, som skickar dem i stället för att vänta på nästa uppdatering.
• Webbskrapning: för en webbplats utan RSS- eller Atom-flöde läser FreshRSS själva sidan med XPath-regler, och den kan också läsa JSON-dokument.
• Delningen: ett urval av artiklar kan publiceras på nytt som HTML, RSS eller OPML.
• Apparna: ett API för mobil- och datorappar, ett kommandoradsgränssnitt och tillägg.

FreshRSS utvecklas av sin gemenskap på GitHub, och den officiella webbplatsen ges ut av FreshRSS-gemenskapen. Tilläggen finns i ett separat förråd, och dokumentationen riktar sig till användare, administratörer och utvecklare.

Det som licensen AGPL-3.0 tillåter

FreshRSS publiceras under GNU Affero General Public License, version 3: dess manifest composer.json deklarerar den som AGPL-3.0, och README-filen länkar till licenstexten. Texten slår fast en obegränsad rätt att köra det oförändrade programmet. Du kan alltså använda avbilden som projektet publicerar för ditt företag och ditt team, utan att köpa någon licens.

Artikel 13 lägger till ett villkor som är särskilt för AGPL: om du ändrar programmet måste din version ge alla som använder den på distans, över nätverket, möjlighet att kostnadsfritt få tag på dess källkod. Ett tillägg från tredje part som läggs i volymen extensions följer sin egen licens.

Installationen med Docker Compose

Projektet publicerar sina officiella avbilder på Docker Hub, under namnet freshrss/freshrss, tillsammans med en exempelfil för Compose. På en server där Docker är installerat skapar du en mapp med namnet freshrss och lägger denna compose.yaml i den, hämtad från den filen och från Docker-README:n:

volumes:
  data:
  extensions:

services:
  freshrss:
    image: freshrss/freshrss:latest
    container_name: freshrss
    hostname: freshrss
    restart: unless-stopped
    logging:
      options:
        max-size: 10m
    volumes:
      - data:/var/www/FreshRSS/data
      - extensions:/var/www/FreshRSS/extensions
    ports:
      - 127.0.0.1:8080:80
    environment:
      TZ: UTC
      CRON_MIN: '3,33'
      TRUSTED_PROXY: 172.16.0.1/12 192.168.0.1/16
    healthcheck:
      test: ["CMD", "cli/health.php"]
      timeout: 10s
      start_period: 60s
      start_interval: 11s
      interval: 75s
      retries: 3

docker compose up -d

• En port som publiceras på 127.0.0.1: FreshRSS nås bara via den omvända proxyn, installerad på samma server. Projektets exempelfil publicerar port 8080 för lokal användning; adressen 127.0.0.1 reserverar den här för proxyn.
• Volymen data innehåller konfigurationen, kontona och, med SQLite, varje användares databas. README-filen påpekar att den innehåller alla personuppgifter. Docker Compose namnger den efter mappen: freshrss_data.
• Volymen extensions innehåller tillägg från tredje part, om du lägger till några.
• TZ tar serverns tidszon, i PHP-format; standardvärdet är UTC.
• TRUSTED_PROXY behåller värdet från exempelfilen: de privata adressintervall som proxyns förfrågningar kommer från. Det avgör vilken adress som hamnar i loggarna, besökarens eller proxyns.
• Hälsokontrollen kör cli/health.php med jämna mellanrum, så att Docker vet om instansen svarar.

Taggen latest, standardvalet, följer den senaste numrerade versionen; edge följer den löpande utgåvan; en tagg som 1.30.4 låser en version, och suffixet -alpine ger samma sak på en Alpine-bas i stället för Debian. Avsnittet om uppdateringar återkommer till det valet.

Slutföra installationen

När den omvända proxyn är på plats öppnar du din HTTPS-adress: installationsguiden frågar efter språket, kontrollerar servern, erbjuder valet av databas och skapar sedan administratörskontot, med dess lösenord och inloggningsmetod. SQLite fungerar utan några förberedelser. Installationen går också att göra från kommandoraden, med cli/do-install.php och cli/create-user.php, körda via docker exec --user www-data freshrss.

När det gäller resurser begär README-filen en lätt server, med Linux eller Windows, och påpekar att FreshRSS till och med körs på en Raspberry Pi 1, med svarstider under en sekund, med 150 flöden och 22 000 artiklar. Storleken beror på antalet användare, flöden och sparade artiklar. På en Managed VPS beskriver du hur du tänker använda den, så rekommenderar vi lämplig storlek.

HTTPS: den omvända proxyn

För produktion råder Docker-README:n till en omvänd proxy på värdservern, som står för HTTPS. Välj först ett domännamn eller en underdomän, som rss.example.com, som pekar mot servern med A- och AAAA-poster. Projektet rekommenderar Traefik och publicerar en komplett Compose-fil för den, med certifikat från Let’s Encrypt och omdirigeringen från HTTP till HTTPS; det ger också exempel för Apache, Nginx och Caddy.

Med Caddy

Caddy hämtar certifikatet och aktiverar HTTPS på egen hand. Det här blocket följer dokumentationens exempel för en underdomän, här riktat mot porten som publiceras lokalt:

rss.example.com {
  reverse_proxy 127.0.0.1:8080
}

Med Nginx och Certbot

Det här blocket följer Nginx-exemplet i Docker-README:n för en domänrot, begränsat till port 80 så att Certbot kan installera HTTPS. De två sista raderna skickar vidare huvudet Authorization, som Google Reader-API:et behöver:

upstream freshrss {
  server 127.0.0.1:8080;
  keepalive 64;
}

server {
  listen 80;
  listen [::]:80;
  server_name rss.example.com;

  location / {
    proxy_pass http://freshrss/;
    proxy_redirect off;
    proxy_buffering off;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Port $server_port;
    proxy_read_timeout 90;

    proxy_set_header Authorization $http_authorization;
    proxy_pass_header Authorization;
  }
}

Certbot installerar sedan certifikatet och sköter förnyelsen:

sudo certbot --nginx

Den publika adressen: base_url

FreshRSS sparar sin publika adress i base_url, i filen data/config.php. API:et och WebSub bygger på den: kontrollera att den innehåller din adress i https. Docker-README:n visar var filen finns i volymen:

docker volume inspect freshrss_data
sudo nano /var/lib/docker/volumes/freshrss_data/_data/config.php
docker compose restart freshrss

'base_url' => 'https://rss.example.com/',

Uppdatera flödena: CRON_MIN

FreshRSS hämtar nya artiklar med sitt skript app/actualize_script.php. Docker-avbilden levereras med ett schemalagt jobb som kör det vid de minuter som anges i CRON_MIN. Utan den variabeln, eller med ett tomt värde, förblir jobbet avstängt och flödena uppdateras inte längre av sig själva.

• Takten: projektet rekommenderar ungefär två körningar i timmen, till exempel 13,43; */20 fungerar också.
• Gränsen: skriptet uppdaterar inte samma flöde oftare än var tjugonde minut, så ett tätare schema ger ingenting.
• Realtid: WebSub tar över för kompatibla källor. Det kräver en publik adress, som läses från base_url, och installationsguiden slår på det när servern har en.

En annan dokumenterad metod: ett schemalagt jobb på värdservern, som anropar skriptet inuti containern. Ta i så fall bort CRON_MIN ur compose.yaml, så att bara en metod används:

7,37 * * * * root docker exec --user www-data freshrss php ./app/actualize_script.php > /tmp/FreshRSS.log 2>&1

Sedan version 1.30.0 vägrar FreshRSS som standard adresser i det lokala nätverket, som 127.0.0.1, för att skydda mot förfalskade förfrågningar från serversidan. En närliggande tjänst som producerar flöden, som RSS-Bridge, tillåts via variabeln INTERNAL_HOST_ALLOWLIST, i formen rss-bridge:80, eller i systemkonfigurationen. Värdet * tar bort alla kontroller, och dokumentationen kallar det osäkert.

Konton och inloggning

Under installationen erbjuder FreshRSS inloggning via formulär, som kräver JavaScript. Det är standardmetoden, och den passar de flesta instanser. Dokumentationen beskriver andra:

Dokumentationen varnar för att FreshRSS litar på varje adress som listas i TRUSTED_PROXY: en dåligt skyddad proxy skulle låta en angripare sätta huvudet och få administratörsåtkomst. Här lyssnar porten bara på 127.0.0.1, vilket reserverar den för serverns egen proxy. Dokumentationen avråder också från varje instans utan autentisering så snart servern går att nå utanför ditt nätverk.

Registreringar och användare

• Stängda som standard: konfigurationen sätter antalet konton till 1, administratörens. Registreringsformuläret visas bara om du höjer det antalet, under Administration, Systemkonfiguration; 0 tar bort all begränsning.
• Konton som administratören skapar: Administration, Hantera användare, med språk, användarnamn, lösenord och om kontot är administratör.
• Ny autentisering krävs före känsliga åtgärder, som att befordra en användare eller tillämpa en uppdatering, efter 20 minuter som standard.
• Verifieringen av e-postadressen är valfri. Den kräver en SMTP-server, inställd med mailer och smtp i data/config.php: dokumentationen anger att utskick via PHP-funktionen mail ännu inte stöds i de officiella Docker-avbilderna.

För en instans som delas av flera personer råder dokumentationen att öppna konton för personer du litar på och att hålla instansen bakom en proxy eller en brandvägg som blockerar åtkomsten till interna adressintervall.

Mobilapparna: API:erna Google Reader och Fever

FreshRSS fungerar i webbläsaren, på stora som små skärmar, och i appar för Android, iOS, Linux, Windows och macOS. De här apparna använder ett av dess två API:er: Google Reader, som README-filen bedömer som det bästa, och Fever, med mer begränsade funktioner, mindre effektivt och mindre säkert.

1. Som administratör, i avsnittet Autentisering, slår du på alternativet som tillåter åtkomst via API:et.
2. Varje användare väljer ett API-lösenord i sin profil. Det är skilt från huvudlösenordet, ger åtkomst till färre saker och är avsett för mindre säkra situationer.
3. I appen anger du adressen https://rss.example.com/api/greader.php, eller https://rss.example.com/api/fever.php för Fever, med användarnamnet och det API-lösenordet.

För att kontrollera öppnar länken som visas bredvid API-lösenordet, i profilen, en testsida: PASS på den fullständiga kontrollen bekräftar att allt fungerar. Docker-avbilden ställer redan in Apache så att kodade snedstreck godtas, vilket vissa appar behöver; med Nginx framför behåller du vidarebefordringen av huvudet Authorization.

README-filen har en tabell över kompatibla appar, med plattform, API och funktioner: bland andra Capy Reader och Readrops på Android, FeedFlow på mobil och dator, RSS Guard och NewsFlash på dator, ReadKit och Reeder Classic på iOS och macOS.

SQLite, PostgreSQL, MySQL eller MariaDB

FreshRSS har SQLite inbyggt, vilket Docker-README:n beskriver som det enklaste alternativet, med goda prestanda. Sidan med systemkrav rekommenderar PostgreSQL 10 eller senare, och godtar också MariaDB 10.6 och MySQL 8.0 eller senare. Valet görs i installationsguiden.

För PostgreSQL lägger du till den här tjänsten i compose.yaml, hämtad från projektets fil docker-compose-db.yml, och volymen db i listan över volymer. Lösenordet läggs i en fil .env, bredvid compose.yaml:

  freshrss-db:
    image: postgres:18
    container_name: freshrss-db
    hostname: freshrss-db
    restart: unless-stopped
    logging:
      options:
        max-size: 10m
    volumes:
      - db:/var/lib/postgresql
    environment:
      POSTGRES_DB: freshrss
      POSTGRES_USER: freshrss
      POSTGRES_PASSWORD: ${DB_PASSWORD}

DB_PASSWORD='a-long-unique-password'

I guiden väljer du PostgreSQL och anger freshrss-db som värd, med användaren, lösenordet och databasen freshrss.

Du kan ompröva valet senare. Dokumentationen beskriver hur du byter från en databas till en annan, från MySQL till PostgreSQL till exempel, eller till en nyare huvudversion av PostgreSQL: cli/db-backup.php kopierar varje användares databas till en SQLite-fil, och sedan läser cli/db-restore.php in den i den nya databasen.

Säkerhetskopiorna

README-filen anger att FreshRSS levereras helt utan garanti: dina säkerhetskopior bevarar dina prenumerationer, dina artiklar och dina inställningar. Det här är vad dokumentationen ber dig att säkerhetskopiera:

Volymerna, med tjänsten stoppad

Dokumentationen anser det säkrare att stoppa tjänsten under underhållsåtgärder. Docker-volymerna kopieras med en tillfällig container, den metod som beskrivs i Dockers dokumentation:

docker compose stop freshrss
docker run --rm --volumes-from freshrss -v "$PWD":/backup ubuntu tar -czf /backup/freshrss-$(date +%F).tgz --exclude=data/cache -C /var/www/FreshRSS data extensions
docker compose start freshrss

Databaserna, med tjänsten igång

Sedan version 1.29.1 kan FreshRSS själv exportera varje användares databas till en SQLite-fil, oavsett vilken databas du använder, och bara behålla de senaste. Slå på den exporten i data/config.php:

'auto_sqlite_export' => [
    'enabled' => true,
    'retention' => 7,
],

Schemalägg sedan kommandot på servern, här varje natt. Varje körning skriver data/users/<user>/sqlite-backups/<date>.sqlite och tar bort filerna utöver de sju senaste:

20 2 * * * root docker exec --user www-data freshrss cli/export-sqlite-auto.php --quiet

Med PostgreSQL lägger du till en export med databasens eget verktyg, som i Docker-README:n. Alternativet -T tar bort terminalen, som ett schemalagt jobb inte har någon nytta av:

docker compose exec -T freshrss-db pg_dump -U freshrss freshrss | gzip -9 > freshrss-postgres-$(date +%F).sql.gz

OPML-exporten, från gränssnittet, säkerhetskopierar din lista över flöden, utan vissa inställningar som är särskilda för FreshRSS, som inloggningsuppgifter eller regler för sidskrapning. För en fullständig kopia behåller du SQLite-exporterna: lagda på serverns disk ingår de också i dess nattliga säkerhetskopior.

Återställa

1. Stoppa FreshRSS med docker compose stop freshrss.
2. Läs tillbaka arkivet i volymerna: docker run --rm --volumes-from freshrss -v "$PWD":/backup ubuntu tar -xzf /backup/freshrss-YYYY-MM-DD.tgz -C /var/www/FreshRSS.
3. Med en extern databas återställer du den från dess export, eller från SQLite-filerna med cli/db-restore.php --delete-backup --force-overwrite.
4. Starta igen med docker compose start freshrss och kontrollera sedan att dina flöden och artiklar finns kvar.

Upprepa övningen då och då, på en kopia: så kontrollerar du att en säkerhetskopia fungerar.

Uppdateringarna

Docker-README:n anger två kommandon, från mappen med compose.yaml. Volymerna ligger kvar:

docker compose pull
docker compose up -d

FreshRSS publicerar i två kanaler. De numrerade versionerna, taggen latest, kommer ut några gånger om året, utan fast kalender, och deras rättelser förs inte tillbaka till äldre versioner. Den löpande utgåvan, taggen edge, får nya funktioner och rättelser allteftersom de tillkommer: sedan version 1.30.0 rekommenderar projektet den för snabbare säkerhetsrättelser.

• Säkerhetskopiera först: dokumentationen ber om en säkerhetskopia av data/, tilläggen och databasen före varje uppdatering.
• Version för version: om du ligger flera versioner efter går du igenom var och en, till exempel från 1.26.0 till 1.27.1 före 1.28.1, med en kontroll vid varje steg. Med Docker gör taggar som 1.29.1 den vägen möjlig.
• De senaste versionerna: 1.30.4 från den 21 oktober 2026 är den fjärde säkerhetsversionen i serien 1.30. Den rättar sårbarheter i PHP i Alpine-avbilderna, efter 1.30.3, som flyttade standardavbilden för Debian till Debian 13.

För att följa nya versioner publicerar projektet ett Atom-flöde med sina versioner: prenumerera på det i din egen FreshRSS-instans.

Vem gör vad på en Managed VPS

Att självhosta innebär att sköta servern utöver applikationen. På en Managed VPS tar våra team hand om servern och följer din instans proaktivt; FreshRSS förblir din programvara, med sina inställningar och sina data.

Om du föredrar att våra team ingriper i själva applikationen faktureras den tjänsten per timme eller som fast pris, med en offert som lämnas före ingreppet.