Linux Installation Guide for digna Release 2026.06¶

Release: 2026.06

Senast uppdaterad: 5 september 2026

Table of Contents¶

1. Introduktion
2. Systemkrav
3. Förberedelser inför installation
4. PostgreSQL-serverinställning
5. Webbserverkonfiguration
6. Initial installation
7. Backendkonfiguration
8. Dashboardkonfiguration
9. Köra digna som en systemd-tjänst
10. Uppgradering till en ny release

Introduktion¶

Om digna¶

digna är en omfattande AI-driven plattform utformad för att optimera hanteringen av datakvalitet i olika data­miljöer såsom warehouses, lakes och lakehouses. Byggd för hög skalbarhet och anpassningsbarhet adresserar digna moderna data­utmaningar genom automation, realtidsövervakning och anomali­detektion.

digna består av två huvudkomponenter:

• dignabackend: Applikationens kärnmotor, ansvarig för databehandling och kvalitetskontroller.
• dignadashboard: Ett webbaserat gränssnitt hostat på en webbserver som ger ett användarvänligt sätt att interagera med digna-plattformen och visualisera datakvalitets­mått.

Nytt i Release 2026.06¶

Denna release för in dataobservability-funktioner direkt i din kod, vilket gör det möjligt för utvecklare att övervaka datakvalitet vid källan. Se versionsanteckningarna för fullständiga detaljer.

Letar du efter Windows eller macOS?¶

Denna guide täcker Linux. För andra plattformar, se Windows-installationsguide eller macOS-installationsguide.

Vilken distribution täcker guiden?¶

Instruktionerna är skrivna för de två vanligaste serverfamiljerna. Där de skiljer sig anges båda kommandon:

• Debian-familjen — Debian, Ubuntu. Paket­hanterare: apt.
• RHEL-familjen — Red Hat Enterprise Linux, Rocky Linux, AlmaLinux, Fedora. Paket­hanterare: dnf.

Valfri modern distribution med systemd fungerar; det är främst paketnamnen och ett fåtal konfigurationsvägar som skiljer.

Systemkrav¶

Innan du börjar installationen, kontrollera att ditt system möter följande minimikrav:

Alternativ för databasinstallation¶

Om PostgreSQL redan är installerat: Du kan lägga till en ny databas för digna på din befintliga PostgreSQL-server.

Om du installerar PostgreSQL på samma maskin som digna:

Kontrollera din distribution och arkitektur¶

Flera kommandon i denna guide skiljer sig mellan Debian- och RHEL-familjerna. För att se vilken du har, kör:

cat /etc/os-release
uname -m

• ID=ubuntu eller ID=debian — använd apt-kommandona.
• ID=rhel, rocky, almalinux eller fedora — använd dnf-kommandona.
• x86_64 eller aarch64 — arkitekturen för det installationspaket du behöver.

Förberedelser inför installation¶

Innan du installerar digna, säkerställ att två viktiga förutsättningar är på plats:

1. PostgreSQL-server – för att lagra beräknade mått och prestandadata
2. Webbserver – för att hosta digna Dashboard

Om dessa komponenter inte redan är uppsatta, följ avsnitten nedan för att installera och konfigurera dem.

Uppdatera paketindexet¶

Uppdatera paketlistorna innan du installerar något:

sudo apt update

sudo dnf check-update

PostgreSQL-serverinställning¶

Om du redan har PostgreSQL¶

Om PostgreSQL redan är installerat och körs lokalt eller om du använder en hanterad fjärr-PostgreSQL, kan du hoppa till nästa avsnitt: Webbserverkonfiguration.

Installera PostgreSQL¶

Steg 1: Installera serverpaketet¶

sudo apt install -y postgresql postgresql-contrib

sudo dnf install -y postgresql-server postgresql-contrib

Steg 2: Initiera databas-klustret¶

På Debian-familjen skapar och startar paketet ett kluster automatiskt — hoppa till nästa steg.

På RHEL-familjen måste klustret skapas explicit:

sudo postgresql-setup --initdb

Steg 3: Starta och aktivera tjänsten¶

sudo systemctl enable --now postgresql

Detta startar PostgreSQL omedelbart och konfigurerar det att starta automatiskt vid uppstart.

Steg 4: Verifiera installationen¶

psql --version
sudo systemctl status postgresql

Du bör se PostgreSQL-versionen och en tjänst i status active (running).

Steg 5: Anslut till servern¶

Ett Linuxpaket för PostgreSQL skapar ett systemkonto postgres som äger klustret. Anslut via det kontot:

sudo -u postgres psql

Steg 6: Bekräfta porten¶

Standardporten för PostgreSQL är 5432. För att bekräfta vilken port din server lyssnar på:

sudo -u postgres psql -c "SHOW port;"

Notera värdet — du kommer att behöva det när du konfigurerar digna-backend.

Steg 7: Aktivera lösenordsautentisering för digna-användaren¶

digna ansluter till PostgreSQL över TCP som digna_user, vilket kräver lösenordsautentisering istället för peer-autentisering. Kontrollera att din pg_hba.conf tillåter detta.

Lokalisera filen:

sudo -u postgres psql -c "SHOW hba_file;"

Öppna den i en editor och se till att lokala TCP-rader använder scram-sha-256 (eller md5 på äldre servrar) istället för ident:

# TYPE  DATABASE  USER  ADDRESS         METHOD
host    all       all   127.0.0.1/32    scram-sha-256
host    all       all   ::1/128         scram-sha-256

Ladda om PostgreSQL efter ändring:

sudo systemctl reload postgresql

Steg 8: Om PostgreSQL körs på en annan maskin¶

För att acceptera anslutningar från en annan host, sätt listen_addresses i postgresql.conf och lägg till en matchande host-rad för ditt nätverk i pg_hba.conf:

listen_addresses = '*'

Öppna sedan porten i brandväggen och starta om tjänsten:

sudo ufw allow 5432/tcp

sudo firewall-cmd --permanent --add-port=5432/tcp && sudo firewall-cmd --reload

sudo systemctl restart postgresql

Webbserverkonfiguration¶

digna kräver en webbserver för att hosta dashboarden. Välj ett av följande alternativ:

• nginx — lättviktigt och rekommenderas
• Apache httpd — ett ofta använt alternativ

Du behöver endast installera och konfigurera en av dessa servrar.

Båda avsnitten konfigurerar två saker som dashboarden är beroende av:

• Fallback för single-page-applikationen, så att en uppdatering av en dashboard-URL inte ger en 404
• En .md MIME-typ, så att Markdown-filer serveras korrekt

nginx-inställning¶

Översikt¶

nginx är en lättviktig, högpresterande webbserver väl lämpad för att servera den statiska digna-dashboarden.

Installation¶

sudo apt install -y nginx

sudo dnf install -y nginx

Starta nginx¶

sudo systemctl enable --now nginx

Verifiera installationen¶

1. Öppna din webbläsare
2. Navigera till http://localhost
3. Du bör se nginx välkomstsida

Öppna brandväggen¶

Om servern nås från andra maskiner, tillåt HTTP-trafik:

sudo ufw allow 'Nginx Full'

sudo firewall-cmd --permanent --add-service=http && sudo firewall-cmd --reload

Konfigurera en site för dashboarden¶

nginx inkluderar varje fil i sin conf.d-katalog på båda distributionsfamiljerna. Skapa en dedikerad konfigurationsfil för digna där:

sudo nano /etc/nginx/conf.d/digna.conf

Klistra in följande och ersätt /opt/digna/dashboard med den faktiska sökvägen till din uppackade dashboard-mapp:

server {
    listen       80 default_server;
    listen       [::]:80 default_server;
    server_name  _;

    root   /opt/digna/dashboard;
    index  index.html;

    # Serve Markdown files with the correct MIME type.
    types {
        text/markdown  md;
    }

    # Single-page-application fallback: unknown paths return index.html
    # instead of a 404, so dashboard routes survive a browser refresh.
    location / {
        try_files $uri $uri/ /index.html;
    }
}

Inaktivera standard­sidan¶

Endast en serverblock kan vara default_server för en port. På Debian-familjen, ta bort det paketlevererade standardblocket så att det inte kolliderar:

sudo rm /etc/nginx/sites-enabled/default

På RHEL-familjen, kommentera ut eller ta bort server { ... }-blocket i /etc/nginx/nginx.conf.

Tillämpa konfigurationen¶

Testa konfigurationen för syntaxfel, och ladda sedan om nginx:

sudo nginx -t
sudo systemctl reload nginx

Apache httpd-inställning¶

Översikt¶

Apache httpd finns i standardförvaren för alla stödda distributioner. Paketet heter apache2 i Debian-familjen och httpd i RHEL-familjen.

Installation¶

sudo apt install -y apache2

sudo dnf install -y httpd

Starta Apache¶

sudo systemctl enable --now apache2

sudo systemctl enable --now httpd

Verifiera installationen¶

1. Öppna din webbläsare
2. Navigera till http://localhost
3. Du bör se distributionens standard Apache-sida

Obligatoriskt: Aktivera mod_rewrite¶

Dashboarden kräver URL-omskrivning.

På Debian-familjen, aktivera modulen och starta om:

sudo a2enmod rewrite
sudo systemctl restart apache2

På RHEL-familjen laddas mod_rewrite som standard. Bekräfta det:

httpd -M | grep rewrite

Obligatoriskt: Tillåt .htaccess-överstyrningar¶

Öppna konfigurationsfilen för ditt dokumentrot:

sudo nano /etc/apache2/apache2.conf

sudo nano /etc/httpd/conf/httpd.conf

Leta reda på <Directory>-blocket som täcker din dokumentrot (/var/www/html på båda familjerna) och ändra:

AllowOverride None

till:

AllowOverride All

Obligatoriskt: MIME-typ för Markdown-filer¶

I samma fil, lägg till följande rad så att Markdown-filer serveras korrekt:

AddType text/markdown .md

Tillämpa konfigurationen¶

Kontrollera konfigurationen för syntaxfel, och starta sedan om Apache:

sudo apachectl configtest
sudo systemctl restart apache2

sudo apachectl configtest
sudo systemctl restart httpd

Initial installation¶

Steg 1: Skapa digna-repositoryt¶

digna-repositoryt lagrar alla mått som digna beräknar. Det fungerar som central databas för analytiska och prestandamätningar.

Skapa schema och användare för repositoryt¶

Öppna din PostgreSQL-klient (psql, pgAdmin eller liknande) och kör följande SQL-kommandon:

CREATE SCHEMA <digna_repo_schema>;

CREATE USER <digna_repo_user> WITH PASSWORD '<digna_repo_password>';

GRANT ALL PRIVILEGES ON SCHEMA <digna_repo_schema> TO <digna_repo_user>;

Byt ut följande platshållare:

• <digna_repo_schema> — Ditt önskade schemanamn (t.ex. dignarepo)
• <digna_repo_user> — Ditt önskade användarnamn (t.ex. digna_user)
• <digna_repo_password> — Ett säkert lösenord för denna användare

Exempel:

CREATE SCHEMA dignarepo;

CREATE USER digna_user WITH PASSWORD 'YourSecurePassword123!';

GRANT ALL PRIVILEGES ON SCHEMA dignarepo TO digna_user;

För att köra dessa från shell i ett steg:

sudo -u postgres psql

Klistra sedan in satserna vid prompten postgres=# och skriv \q för att avsluta.

Steg 2: Packa upp digna-installationspaketet¶

1. Hitta digna-installations-ZIP-filen som du fått
2. Packa upp den till din önskade installationsplats — till exempel /opt/digna
3. Efter uppackning bör du se följande objekt:
4. dashboard/ — Webbgränssnittet
5. digna — Huvudkörbar fil (backend + CLI i ett)
6. config.toml — Konfigurationsfil
7. license.toml — Licensfil (kopiera din fil hit)

För att packa upp från shell:

sudo mkdir -p /opt/digna
sudo unzip digna-2026.06-linux-x86_64.zip -d /opt/digna

Gör den körbara filen körbar¶

Beroende på hur arkivet överfördes kan den körbara filens rättigheter ha förlorats. Sätt den uttryckligen:

cd /opt/digna
sudo chmod +x digna

Skapa ett servicekonto¶

Det rekommenderas att köra backend som en dedikerad oprivilegierad användare i produktionsmiljö:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin digna
sudo chown -R digna:digna /opt/digna

Steg 3: Installera licensfilen¶

1. Hitta license.toml-filen som du fått
2. Kopiera den till rotmappen för digna-installationen (där config.toml och den körbara digna finns)

Varför detta är viktigt: Licensfilen innehåller din kundinformation, licensens utgångsdatum och en digital signatur. Ändra inte denna fil — ändringar gör att den ogiltigförklaras.

Katalogstruktur efter installation:

/opt/digna/
├── config.toml         (configuration file)
├── license.toml        (YOUR LICENSE FILE - copy here)
├── digna               (main executable)
├── bin/                (service management scripts)
└── dashboard/          (web interface)
    └── (dashboard files)

Backendkonfiguration¶

Steg 1: Skapa och redigera konfigurationsfilen¶

Filen config_template.toml medföljer din digna-installation. Du behöver bara byta namn på den till config.toml.

cd /opt/digna
sudo mv config_template.toml config.toml

Plats: /opt/digna/config.toml

Öppna config.toml i en texteditor och konfigurera varje sektion nedan.

[app] Sektionen¶

Denna sektion konfigurerar digna-backendens applikationsinställningar:

[app]
digna_APP_HOST = "localhost"
digna_APP_PORT = 8082
digna_APP_CORS_ALLOW_ORIGINS = ["http://localhost:5173"]
digna_APP_CORS_ALLOW_CREDENTIALS = true
digna_APP_CORS_ALLOW_METHODS = ["*"]
digna_APP_CORS_ALLOW_HEADERS = ["*"]

[repo] Sektionen¶

Denna sektion konfigurerar anslutningen till PostgreSQL-databasen:

[repo]
digna_REPO_HOST = "localhost"
digna_REPO_PORT = 5432
digna_REPO_DB = "postgres"
digna_REPO_SCHEMA = "dignarepo"
digna_REPO_USER = "digna_user"
digna_REPO_PASSWORD = "YourSecurePassword123!"

sudo chown digna:digna /opt/digna/config.toml
sudo chmod 600 /opt/digna/config.toml

[base] Sektionen¶

Denna sektion innehåller säkerhets- och cookie-inställningar:

[base]
digna_FERNET_KEY = "your-fernet-key"
digna_COOKIE_DOMAIN = "localhost"
digna_COOKIE_PATH = "/"
digna_COOKIE_SECURE = false
digna_COOKIE_HTTPONLY = true
digna_COOKIE_SAME_SITE = "lax"
digna_TOKEN_EXPIRES_IN = 86400
digna_MAX_WORKERS = 4

[logging] Sektionen¶

Denna sektion konfigurerar loggningsbeteende:

[logging]
digna_LOGGING_MODE = "INFO"
digna_LOGGING_BACKUP_COUNT = 10

Steg 2: Initiera repositoryt¶

1. Öppna en terminal
2. Navigera till din digna-installationskatalog (där config.toml och den körbara digna finns)
3. Kör anslutningstestet:

cd /opt/digna
./digna repo check

Du bör se en bekräftelse på att anslutningen upprättats (själva repositoryt har ännu inte initierats).

sudo ln -s /opt/digna/digna /usr/local/bin/digna

Steg 3: Installera repositoryschemat¶

I samma katalog, kör:

./digna repo install

Detta kommando installerar nödvändiga tabeller och schema i din PostgreSQL-databas.

Steg 4: Starta digna-servern¶

I digna-installationskatalogen, starta servern med:

./digna serve --address <host> --port <port>

Parametrar: - --address — Serverns hostnamn/IP - --port — Serverns port

Du bör se startmeddelanden som bekräftar att servern körs:

INFO:     Started server process [1234]
INFO:     Waiting for application startup.
INFO:     Application startup complete
INFO:     Uvicorn running on http://localhost:8082

sudo ufw allow 8082/tcp

sudo firewall-cmd --permanent --add-port=8082/tcp && sudo firewall-cmd --reload

Steg 5: Skapa en administratörsanvändare¶

1. Öppna ett nytt terminalfönster
2. Navigera till din digna-installationskatalog
3. Kör följande kommando för att skapa en administratörsanvändare:

./digna user add <username> "<full_name>" <password> --su

Exempel:

./digna user add admin "Admin User" 'AdminPassword123!' --su

Detta skapar en användare med användarnamn admin och fullständiga administrativa rättigheter.

Dashboardkonfiguration¶

Steg 1: Distribuera dashboarden till webbservern¶

Digna-dashboarden har en separat config.toml-fil i dashboard/-katalogen. Denna konfiguration medföljer redan och kräver normalt inga ändringar under initial setup. Du behöver bara ändra den om du vill anpassa backend-anslutningen.

Om du behöver modifiera dashboardkonfigurationen (t.ex. för multi-instance-uppsättningar), se dashboardens dokumentation.

Välj din webbserver och följ motsvarande distributionssteg.

Distribuera till nginx¶

Om du följt nginx-inställningen pekar serverblocket redan mot din dashboard-mapp och ingen kopiering krävs.

1. Bekräfta sökvägen
2. Öppna /etc/nginx/conf.d/digna.conf

3. Verifiera att root pekar mot din uppackade dashboard-mapp

4. Säkerställ att mappen är läsbar

   sudo chmod -R a+rX /opt/digna/dashboard
   

5. Ladda om nginx

   sudo nginx -t
   sudo systemctl reload nginx
   

6. Testa installationen

7. Öppna din webbläsare
8. Navigera till http://localhost (eller din konfigurerade URL)
9. Du bör se inloggningssidan för digna-dashboarden

Distribuera till Apache httpd¶

1. Kopiera dashboarden till dokumentroten

   sudo cp -R /opt/digna/dashboard /var/www/html/digna
   

2. Lägg till omskrivningsregler

Skapa en .htaccess-fil i den deployade mappen så att dashboard-routes överlever en webbläsaruppdatering:

sudo nano /var/www/html/digna/.htaccess

Klistra in följande:

RewriteEngine On
RewriteBase /digna/

# Serve existing files and directories as-is.
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]

# Everything else falls back to the single-page application entry point.
RewriteRule ^ index.html [L]

1. Starta om Apache

   sudo systemctl restart apache2
   

   sudo systemctl restart httpd
   

2. Åtkomst till dashboarden

3. Öppna din webbläsare
4. Navigera till http://localhost/digna
5. Du bör se inloggningssidan för digna-dashboarden

Steg 2: SELinux (endast RHEL-familjen)¶

På RHEL, Rocky, AlmaLinux och Fedora är SELinux som standard i enforcing-läge och kommer att blockera webbservern från att läsa filer utanför förväntade platser. Kontrollera om det är aktivt:

getenforce

Om resultatet är Enforcing och du serverar dashboarden från /opt/digna/dashboard, märk katalogen så att webbservern får läsa den:

sudo semanage fcontext -a -t httpd_sys_content_t "/opt/digna/dashboard(/.*)?"
sudo restorecon -Rv /opt/digna/dashboard

Köra digna som en systemd-tjänst¶

Varför köra digna som en tjänst?¶

Att köra digna-backenden som en systemd-tjänst säkerställer att den:

• Startar automatiskt när maskinen startas
• Körs i bakgrunden utan ett öppet terminalfönster
• Startas om automatiskt om den kraschar
• Kan hanteras via systemctl, standardverktyget för Linux-tjänster

Tjänsthanteringsfiler¶

Alla nödvändiga filer finns i digna-installationskatalogen under: bin/

Följande shell-skript finns tillgängliga:

• install_service.sh — Registrerar digna med systemd
• uninstall_service.sh — Avregistrerar tjänsten
• start_service.sh — Startar den registrerade tjänsten
• stop_service.sh — Stoppar den körande tjänsten

Gör skripten körbara¶

Uppackning bevarar kanske inte exekveringsrättigheterna. Innan första användning:

cd /opt/digna/bin
sudo chmod +x *.sh

Installera tjänsten¶

1. Öppna en terminal

2. Gå till bin-mappen

   cd /opt/digna/bin
   

3. Kör installationsskriptet

   sudo ./install_service.sh
   

digna-servern är nu registrerad i systemd med automatisk start aktiverad. Tjänsten startar dock inte omedelbart — se nästa avsnitt för att starta den.

Starta och stoppa tjänsten¶

För att starta tjänsten¶

1. Öppna en terminal
2. Navigera till /opt/digna/bin
3. Kör:

   sudo ./start_service.sh
   

För att stoppa tjänsten¶

1. Öppna en terminal
2. Navigera till /opt/digna/bin
3. Kör:

   sudo ./stop_service.sh
   

Hantera tjänsten med systemctl¶

När den är registrerad kan tjänsten även kontrolleras med standard systemd-kommandon från valfri katalog:

sudo systemctl start digna
sudo systemctl stop digna
sudo systemctl restart digna
sudo systemctl status digna

Verifiera tjänsten¶

För att bekräfta att tjänsten är registrerad och körs:

systemctl is-enabled digna
systemctl is-active digna

enabled betyder att tjänsten startar vid boot; active betyder att den körs nu.

Visa tjänstens loggar¶

systemd fångar allt som backend skriver till konsolen. För att läsa dem:

sudo journalctl -u digna -n 100

För att följa loggen live medan du reproducerar ett problem:

sudo journalctl -u digna -f

Flytta tjänsten till en ny katalog¶

Enhetsfilen lagrar den absoluta sökvägen till den körbara filen, så att flytta installationen kräver att tjänsten registreras om:

1. Avinstallera den nuvarande tjänsten

   cd /old/path/digna/bin
   sudo ./uninstall_service.sh
   

2. Flytta applikationsfilerna

   sudo mv /old/path/digna /new/path/digna
   

3. Installera om tjänsten

   cd /new/path/digna/bin
   sudo ./install_service.sh
   

4. Starta tjänsten

   sudo ./start_service.sh
   

Avinstallera tjänsten¶

1. Stoppa den körande tjänsten

   cd /opt/digna/bin
   sudo ./stop_service.sh
   

2. Avinstallera tjänsten

   sudo ./uninstall_service.sh
   

digna-servern är nu avregistrerad från systemd.

Uppgradering till en ny release¶

Innan du uppgraderar¶

Det är obligatoriskt att skapa en backup av digna-repositoryt

Innan du uppgraderar digna, säkerhetskopiera ditt repository (PostgreSQL) för att skydda mot dataförlust. En backup säkerställer att du kan återställa om uppgraderingen stöter på oväntade problem.

För att skapa en backup från shell:

pg_dump -h localhost -p 5432 -U digna_user -n dignarepo postgres > digna_repo_backup.sql

Uppgraderingsprocess¶

Steg 1: Stoppa digna-tjänsten¶

Om digna körs som en systemd-tjänst, stoppa den först:

cd /opt/digna/bin
sudo ./stop_service.sh

Om digna körs i förgrunden, tryck Ctrl + C i dess terminalfönster.

Steg 2: Backup av nuvarande backend-installation¶

I din digna-installationskatalog:

cd /opt/digna
sudo mv digna digna_old

sudo mv dashboard dashboard_old

Steg 3: Packa upp och distribuera ny version¶

1. Packa upp den nya digna-installations-ZIP-filen
2. Kopiera den nya digna-körbaren och dashboard-mappen till din installationskatalog
3. Återställ körbarhetsbit och ägarskap för servicekontot:

sudo chmod +x /opt/digna/digna
sudo chown -R digna:digna /opt/digna

Steg 4: Återställ dina konfigurationsfiler¶

sudo cp dashboard_old/dashboard_config.toml dashboard/dashboard_config.toml

Steg 5: Uppgradera repositoryschemat¶

Navigera till din digna-installationskatalog och kör:

cd /opt/digna
./digna repo upgrade

Detta uppdaterar PostgreSQL-schemat till senaste versionen samtidigt som all befintlig data bevaras.

Steg 6: Starta om tjänsterna¶

Om du kör som systemd-tjänst:

cd /opt/digna/bin
sudo ./start_service.sh

Om du kör manuellt, starta servern igen:

cd /opt/digna
./digna serve --address <address> --port <port>

Om du använder nginx eller Apache, ladda om respektive webbserver:

sudo systemctl reload nginx

sudo systemctl restart apache2

På RHEL-familjen, återapplicera SELinux-märkningen om dashboard-katalogen ersattes:

sudo restorecon -Rv /opt/digna/dashboard

Steg 7: Verifiera uppgraderingen¶

1. Gå till digna-dashboarden
2. Verifiera att gränssnittet laddar korrekt
3. Kontrollera serverloggarna efter eventuella fel:

sudo journalctl -u digna -n 100