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:

• digna: applikationens kärna, ansvarig för att bearbeta data och utföra kvalitetskontroller. Den förenar backend och kommandoradsgränssnittet i en enda körbar fil och ersätter därmed de separata programmen dignabackend och dignacli från tidigare releaser.
• 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)

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_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 = "DU4a0yJ-OqvbKCL4hNQn_CsknH-V1vWmHZqBUl-AY44="
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
DIGNA_SCHEDULER_MAX_DELAY = 100
DIGNA_CLEANUP_TIME = "12:00"

[encryption] Sektionen¶

Denna sektion innehåller nyckeln som används för att kryptera känsliga värden i repositoryt. Den är obligatorisk — config check rapporterar sektionen [encryption] som FAILED om nyckeln saknas.

[encryption]
DIGNA_ENCRYPTION_KEY = 'ycELf6IbcO55dYIZHpPv6kQv/bbnUXoIaHLh2bh1kMg='

[logging] Sektionen¶

Denna sektion konfigurerar loggningsbeteende:

[logging]
digna_LOGGING_MODE = "INFO"
digna_LOGGING_BACKUP_COUNT = 10

Steg 2: Validera konfigurationen¶

Kontrollera att config.toml är fullständig och korrekt uppbyggd innan du initierar repositoryt. Kör i din digna-installationskatalog:

./digna config check

Varje sektion valideras för sig, så att ett enskilt fel inte döljer tillståndet hos de övriga:

Configuration validation report (source: config.toml):
 - App config: OK
 - Repository config: OK
 - Base config: OK
 - Logging config: OK
 - Encryption config: OK
 - OIDC config(s): OK

Overall: OK

Åtgärda allt som rapporteras som FAILED och kör kommandot igen innan du fortsätter. Den fullständiga listan över alternativ finns i CLI-referensen.

Steg 3: 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 4: Installera repositoryschemat¶

I samma katalog, kör:

./digna repo install

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

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 <email> <password> "<display_name>" --admin

Exempel:

./digna user add admin@example.com 'AdminPassword123!' "Admin User" --admin

Detta skapar en användare med e-postadressen admin@example.com och fullständiga administratörsrättigheter.

Steg 6: 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

Dashboardkonfiguration¶

Steg 1: Distribuera dashboarden till webbservern¶

digna-dashboarden läser sin egen konfiguration från dashboard/dashboard_config.toml. Den filen medföljer inte installationen — du skapar den i katalogen dashboard/ bredvid dashboardfilerna.

Dess innehåll beskrivs under Enkel inloggning (SSO), som också är där filen behövs: den innehåller de inloggningsalternativ som dashboarden erbjuder och, vid uppsättningar med flera instanser, backend-anslutningen.

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¶

Verifiera alla databasanslutningar först

Från Release 2026.06 når digna varje källteknologi via ODBC. Tidigare releaser erbjöd ett val mellan en teknikspecifik drivrutin och ODBC, via omkopplaren Use ODBC. digna-teamet har valt att bygga enbart på ODBC, eftersom ett enda standardiserat gränssnitt ger mer än en uppsättning skräddarsydda drivrutiner:

• Autentisering — autentisering är en del av ODBC, så en anslutning kan använda allt som dess drivrutin stöder: lösenord, tokens och PAT:ar, Kerberos och Active Directory, MFA och webbläsarbaserad enkel inloggning, molnidentiteter, klientcertifikat och TLS. Nya metoder kommer med en uppdatering av drivrutinen i stället för att vänta på en digna-release.
• Drivrutiner som underhålls av databasleverantörerna — leverantörens egen drivrutin följer nya serverversioner och säkerhetsfixar, och du kan uppdatera den enligt ditt eget schema, oberoende av digna.
• Ett enda sätt att konfigurera allt — varje teknik är en lista med nyckel/värde-egenskaper, med samma gränssnitt, samma kryptering av känsliga värden och samma felsökning, i stället för olika fält per källa.
• Finjustering och räckvidd — drivrutinsalternativ som timeouts, TLS-inställningar, proxyservrar och hämtningsstorlekar är tillgängliga för varje källa, och varje teknik med en kompatibel ODBC-drivrutin kan anslutas, även sådana som digna inte publicerar någon egen guide för.

I praktiken innebär detta att omkopplaren Use ODBC och de separata fälten för värd, port, databas, användare och lösenord inte längre finns. Varje anslutning som inte redan använder ODBC måste läggas om till ODBC — det finns ingen automatisk konvertering, så planera för detta före uppgraderingen:

1. Gå igenom varje databasanslutning som är definierad i din installation och notera vilka som ännu inte använder ODBC — var och en av dem måste konfigureras om.
2. Installera motsvarande ODBC-drivrutin på digna-värden — anslutningar öppnas från den server som kör digna-backend, inte från webbläsaren. Se Installera ODBC-drivrutinen på digna-värden.
3. Ha ODBC-egenskaperna redo för varje berörd anslutning. Teknikguiderna listar en beprövad uppsättning egenskaper per källa.

Efter uppgraderingen lägger du om varje berörd anslutning till ODBC och testar den från dashboarden — se Skapa en databasanslutning och Testa en anslutning.

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: Säkerhetskopiera nuvarande installation¶

Byt namn på mapparna i din nuvarande installation i digna-installationskatalogen, så att den nya releasen kan distribueras vid sidan av dem:

cd /opt/digna
sudo mv dignabackend dignabackend_old

sudo mv dignacli dignacli_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

[base]
DIGNA_SCHEDULER_MAX_DELAY = 100
DIGNA_CLEANUP_TIME = "12:00"

[encryption]
DIGNA_ENCRYPTION_KEY = 'ycELf6IbcO55dYIZHpPv6kQv/bbnUXoIaHLh2bh1kMg='

[[oidc_clients]]
DIGNA_OIDC_KEY = 'microsoft'
DIGNA_OIDC_CLIENT_ID = '<client_id>'
DIGNA_OIDC_CLIENT_SECRET = '<client_secret>'
DIGNA_OIDC_REDIRECT_URI = 'http://localhost:3000/oidc/callback'
DIGNA_OIDC_CONFIGURATION_URL = 'https://login.microsoftonline.com/<tenant_id>/v2.0/.well-known/openid-configuration'

[oidc_clients.microsoft]
DIGNA_OIDC_CLIENT_ID = '<client_id>'
DIGNA_OIDC_CLIENT_SECRET = '<client_secret>'
DIGNA_OIDC_REDIRECT_URI = 'http://localhost:3000/oidc/callback'
DIGNA_OIDC_CONFIGURATION_URL = 'https://login.microsoftonline.com/<tenant_id>/v2.0/.well-known/openid-configuration'

Steg 5: Ladda om webbservern¶

Dashboarden är en uppsättning statiska filer, så din webbserver — och webbläsaren — kan fortfarande leverera den tidigare versionen. Ladda om eller starta om den webbserver som är värd för mappen dashboard och ladda sedan om sidan med en hård uppdatering (Ctrl+F5).

Steg 6: Validera konfigurationen¶

Kontrollera att den uppdaterade config.toml är fullständig innan du rör repositoryt:

./digna config check

Varje sektion måste rapportera OK. Åtgärda allt som rapporteras som FAILED och kör kommandot igen innan du fortsätter.

Steg 7: Ersätt licensfilen¶

Varje release licensieras separat. Kopiera den license.toml som digna-teamet tillhandahållit för denna release till installationskatalogen och ersätt den gamla:

sudo cp /path/to/new/license.toml /opt/digna/license.toml

./digna license check

Steg 8: 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 9: 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 10: Verifiera uppgraderingen¶

1. Gå till digna-dashboarden
2. Verifiera att gränssnittet laddar korrekt
3. Kontrollera serverloggarna efter eventuella fel:
4. Lägg om varje anslutning som ännu inte använde ODBC till ODBC och testa sedan alla anslutningar — se Testa en anslutning

sudo journalctl -u digna -n 100