Linux-installasjonsveiledning for digna Release 2026.06¶

Release: 2026.06

Sist oppdatert: 5. september 2026

Innholdsfortegnelse¶

1. Introduksjon
2. Systemkrav
3. Forberedelser før installasjon
4. Oppsett av PostgreSQL-server
5. Webserverkonfigurasjon
6. Første installasjon
7. Backend-konfigurasjon
8. Dashboard-konfigurasjon
9. Kjøre digna som en systemd-tjeneste
10. Oppgradere til en ny utgivelse

Introduksjon¶

Om digna¶

digna er en omfattende, AI-drevet plattform designet for å optimalisere datakvalitetsstyring på tvers av ulike data-miljøer som warehouses, lakes og lakehouses. Bygget for å være svært skalerbar og tilpasningsdyktig, håndterer digna moderne datautfordringer gjennom automatisering, sanntidsovervåking og anomalideteksjon.

digna består av to hovedkomponenter:

• dignabackend: Kjernen i applikasjonen, ansvarlig for å prosessere data og utføre kvalitetskontroller.
• dignadashboard: Et nettbasert grensesnitt hostet på en webserver, som gir en brukervennlig måte å samhandle med digna-plattformen og visualisere datakvalitetsmål.

Hva er nytt i Release 2026.06¶

Denne utgivelsen bringer observabilitet for data direkte inn i koden din, slik at utviklere kan overvåke datakvalitet ved kilden. Se utgivelsesnotatene for fullstendige detaljer.

Ser du etter Windows eller macOS?¶

Denne veiledningen dekker Linux. For andre plattformer, se Windows installasjonsveiledning eller macOS installasjonsveiledning.

Hvilken distribusjon dekker denne veiledningen?¶

Instruksjonene er skrevet for de to mest vanlige serverfamiliene. Der de to avviker, er begge kommandoene oppgitt:

• Debian-familien — Debian, Ubuntu. Pakkehåndterer: apt.
• RHEL-familien — Red Hat Enterprise Linux, Rocky Linux, AlmaLinux, Fedora. Pakkehåndterer: dnf.

Enhver moderne distribusjon med systemd vil fungere; det er bare pakkenavn og noen konfigurasjonsstier som endres.

Systemkrav¶

Før du begynner installasjonen, sørg for at systemet ditt oppfyller følgende minimumskrav:

Databaseinstallasjonsalternativer¶

Hvis PostgreSQL allerede er installert: Du kan legge til en ny database for digna i din eksisterende PostgreSQL-server.

Hvis du installerer PostgreSQL på samme maskin som digna:

Sjekke distribusjon og arkitektur¶

Flere kommandoer i denne veiledningen skiller seg mellom Debian- og RHEL-familiene. For å sjekke hvilken du bruker, kjør:

cat /etc/os-release
uname -m

• ID=ubuntu eller ID=debian — bruk apt-kommandoene.
• ID=rhel, rocky, almalinux eller fedora — bruk dnf-kommandoene.
• x86_64 eller aarch64 — arkitekturen for installasjonspakken du trenger.

Forberedelser før installasjon¶

Før du installerer digna, sørg for at to viktige forutsetninger er på plass:

1. PostgreSQL-server – for å lagre beregnede metrikker og ytelsesdata
2. Webserver – for hosting av digna Dashboard

Hvis disse komponentene ikke allerede er satt opp, følg seksjonene nedenfor for å installere og konfigurere dem.

Oppdatering av pakkelisten¶

Oppdater pakkelistene før du installerer noe:

sudo apt update

sudo dnf check-update

Oppsett av PostgreSQL-server¶

Hvis du allerede har PostgreSQL¶

Hvis PostgreSQL allerede er installert og kjører lokalt eller hvis du bruker en administrert ekstern PostgreSQL-server, kan du hoppe til neste seksjon.

Installere PostgreSQL¶

Steg 1: Installer serverpakken¶

sudo apt install -y postgresql postgresql-contrib

sudo dnf install -y postgresql-server postgresql-contrib

Steg 2: Initialiser databaseklyngen¶

På Debian-familien oppretter og starter pakken en klynge automatisk — hopp til neste steg.

På RHEL-familien må klyngen opprettes eksplisitt:

sudo postgresql-setup --initdb

Steg 3: Start og aktiver tjenesten¶

sudo systemctl enable --now postgresql

Dette starter PostgreSQL umiddelbart og konfigurerer den til å starte automatisk ved oppstart.

Steg 4: Verifiser installasjonen¶

psql --version
sudo systemctl status postgresql

Du bør se PostgreSQL-versjonen og en active (running)-tjeneste.

Steg 5: Koble til serveren¶

En Linux PostgreSQL-pakke oppretter en systemkonto postgres som eier klyngen. Koble til via denne kontoen:

sudo -u postgres psql

Steg 6: Bekreft porten¶

Standard PostgreSQL-port er 5432. For å bekrefte hvilken port serveren lytter på:

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

Noter verdien — du vil trenge den når du konfigurerer digna-backend.

Steg 7: Aktiver passordautentisering for digna-brukeren¶

digna kobler til PostgreSQL over TCP som digna_user, noe som krever passordautentisering fremfor peer authentication. Sjekk at pg_hba.conf tillater dette.

Finn filen:

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

Åpne den i en editor og bekreft at de lokale TCP-linjene bruker scram-sha-256 (eller md5 på eldre servere) i stedet for 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

Reload PostgreSQL etter enhver endring:

sudo systemctl reload postgresql

Steg 8: Hvis PostgreSQL kjører på en annen maskin¶

For å akseptere tilkoblinger fra en annen vert, sett listen_addresses i postgresql.conf og legg til en tilsvarende host-linje for nettverket ditt i pg_hba.conf:

listen_addresses = '*'

Deretter åpner du porten i brannmuren og starter tjenesten på nytt:

sudo ufw allow 5432/tcp

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

sudo systemctl restart postgresql

Webserverkonfigurasjon¶

digna krever en webserver for å hoste dashboardet. Velg ett av følgende alternativer:

• nginx — lettvekts og anbefalt
• Apache httpd — et mye brukt alternativ

Du trenger bare å installere og konfigurere én av disse serverne.

Begge seksjonene konfigurerer to ting dashboardet er avhengig av:

• En single-page-application fallback, slik at oppfrisking av en dashboard-URL ikke returnerer 404
• En .md MIME-type, slik at Markdown-filer serveres riktig

nginx-oppsett¶

Oversikt¶

nginx er en lettvekts, høyytelses webserver som egner seg godt til å servere det statiske digna-dashboardet.

Installasjon¶

sudo apt install -y nginx

sudo dnf install -y nginx

Starte nginx¶

sudo systemctl enable --now nginx

Verifiser installasjonen¶

1. Åpne nettleseren
2. Gå til http://localhost
3. Du bør se nginx-velkomstsiden

Åpne brannmuren¶

Hvis serveren nås fra andre maskiner, tillat HTTP-trafikk:

sudo ufw allow 'Nginx Full'

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

Konfigurere et nettsted for dashboardet¶

nginx inkluderer alle filer i conf.d-katalogen på begge distribusjonsfamilier. Lag en dedikert konfigurasjonsfil for digna der:

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

Lim inn følgende, og erstatt /opt/digna/dashboard med den faktiske stien til din utpakkede dashboard-mappe:

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;
    }
}

(Kommentarene over er i konfigurasjonen; de kan hjelpe ved feilsøking.)

Deaktiver standardnettstedet¶

Kun én serverblokk kan være default_server for en port. På Debian-familien, fjern den medfølgende standarden slik at den ikke konflikter:

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

På RHEL-familien, kommenter ut eller slett server { ... }-blokken inne i /etc/nginx/nginx.conf.

Aktiver konfigurasjonen¶

Test konfigurasjonen for syntaksfeil, og last deretter nginx på nytt:

sudo nginx -t
sudo systemctl reload nginx

Apache httpd-oppsett¶

Oversikt¶

Apache httpd er tilgjengelig i standardreposene for alle støttede distribusjoner. Pakken heter apache2 på Debian-familien og httpd på RHEL-familien.

Installasjon¶

sudo apt install -y apache2

sudo dnf install -y httpd

Starte Apache¶

sudo systemctl enable --now apache2

sudo systemctl enable --now httpd

Verifiser installasjonen¶

1. Åpne nettleseren
2. Gå til http://localhost
3. Du bør se distribusjonens standard Apache-side

Påkrevd: Aktiver mod_rewrite¶

Dashboardet krever URL-omskriving.

På Debian-familien, aktiver modulen og start på nytt:

sudo a2enmod rewrite
sudo systemctl restart apache2

På RHEL-familien lastes mod_rewrite som regel inn som standard. Bekreft det:

httpd -M | grep rewrite

Påkrevd: Tillat .htaccess-overstyringer¶

Åpne konfigurasjonsfilen for dokumentroten:

sudo nano /etc/apache2/apache2.conf

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

Finn <Directory>-blokken som dekker dokumentroten din (/var/www/html på begge familier) og endre:

AllowOverride None

til:

AllowOverride All

Påkrevd: MIME-type for Markdown-filer¶

I samme fil, legg til følgende linje slik at Markdown-filer serveres riktig:

AddType text/markdown .md

Aktiver konfigurasjonen¶

Sjekk konfigurasjonen for syntaksfeil, og start deretter Apache på nytt:

sudo apachectl configtest
sudo systemctl restart apache2

sudo apachectl configtest
sudo systemctl restart httpd

Første installasjon¶

Steg 1: Sett opp digna-repositoriet¶

digna-repositoriet lagrer alle metrikker som beregnes av digna. Det fungerer som den sentrale databasen for analytiske og ytelsesdata.

Opprett repositories-skjema og bruker¶

Åpne din PostgreSQL-klient (psql, pgAdmin eller lignende) og kjør følgende SQL-kommandoer:

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>;

Erstatt følgende plassholdere:

• <digna_repo_schema> — ønsket skjema-navn (f.eks. dignarepo)
• <digna_repo_user> — ønsket brukernavn (f.eks. digna_user)
• <digna_repo_password> — et sikkert passord for denne brukeren

Eksempel:

CREATE SCHEMA dignarepo;

CREATE USER digna_user WITH PASSWORD 'YourSecurePassword123!';

GRANT ALL PRIVILEGES ON SCHEMA dignarepo TO digna_user;

For å kjøre disse fra shell i ett trinn:

sudo -u postgres psql

Lim så inn uttalelsene ved postgres=#-prompten og skriv \q for å avslutte.

Steg 2: Pakk ut digna-installasjonspakken¶

1. Finn digna-installasjons ZIP-filen som er levert til deg
2. Pakk den ut til ønsket installasjonssted — for eksempel /opt/digna
3. Etter utpakking skal du se følgende elementer:
4. dashboard/ — web-dashboard grensesnitt
5. digna — hovedkjørbar (backend + CLI kombinert)
6. config.toml — konfigurasjonsfil
7. license.toml — lisensfil (kopier din fil hit)

For å pakke ut fra shell:

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

Gjør den kjørbare filen kjørbar¶

Avhengig av hvordan arkivet ble overført, kan den kjørbare biten mangle etter utpakking. Sett den eksplisitt:

cd /opt/digna
sudo chmod +x digna

Opprett en tjenestekonto¶

Det anbefales å kjøre backend som en dedikert, uprivilegert bruker for produksjonsdistribusjoner:

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

Steg 3: Installer lisensfilen¶

1. Finn license.toml-filen som er levert til deg
2. Kopier den inn i rotmappen for digna-installasjonen (der config.toml og den kjørbare digna ligger)

Hvorfor dette er viktig: Lisensfilen inneholder kundeinformasjon, lisensutløpsdato og digital signatur. Ikke endre denne filen — enhver endring vil ugyldiggjøre den.

Katalogstruktur etter oppsett:

/opt/digna/
├── config.toml         (konfigurasjonsfil)
├── license.toml        (DIN LISENSFIL - kopier hit)
├── digna               (hovedkjørbar)
├── bin/                (skript for tjenesteadministrasjon)
└── dashboard/          (webgrensesnitt)
    └── (dashboard-filer)

Backend-konfigurasjon¶

Steg 1: Opprett og rediger konfigurasjonsfilen¶

config_template.toml-filen leveres i din digna-installasjonsmappe. Du trenger bare å gi den nytt navn til config.toml.

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

Plassering: /opt/digna/config.toml

Åpne config.toml i en teksteditor og konfigurer hver seksjon nedenfor.

[app]-seksjonen¶

Denne seksjonen konfigurerer digna-backend-applikasjonsinnstillingene:

[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]-seksjonen¶

Denne seksjonen konfigurerer tilkoblingen til 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]-seksjonen¶

Denne seksjonen inneholder sikkerhets- og cookie-innstillinger:

[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]-seksjonen¶

Denne seksjonen konfigurerer loggingsatferd:

[logging]
digna_LOGGING_MODE = "INFO"
digna_LOGGING_BACKUP_COUNT = 10

Steg 2: Initialiser repositoriet¶

1. Åpne et terminalvindu
2. Gå til din digna-installasjonsmappe (der config.toml og digna-kjørbar ligger)
3. Kjør tilkoblingstesten:

cd /opt/digna
./digna repo check

Du bør se en bekreftelse på at tilkoblingen er etablert (selve repoet er ikke initialisert ennå).

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

Steg 3: Installer repositories-skjemaet¶

I samme katalog, kjør:

./digna repo install

Denne kommandoen installerer nødvendige tabeller og skjema i PostgreSQL-databasen.

Steg 4: Start digna-serveren¶

I digna-installasjonskatalogen, start serveren med:

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

Parametere: - --address — Serverens hostnavn/IP - --port — Serverport

Du bør se oppstartsmeldinger som bekrefter at serveren kjører:

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: Opprett en administratorbruker¶

1. Åpne et nytt terminalvindu
2. Gå til din digna-installasjonsmappe
3. Kjør følgende kommando for å opprette en admin-bruker:

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

Eksempel:

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

Dette oppretter en bruker med brukernavn admin og fulle administrative rettigheter.

Dashboard-konfigurasjon¶

Steg 1: Deploy dashboardet til webserveren¶

digna-dashboardet har sin egen separate config.toml-fil plassert i dashboard/-katalogen. Denne konfigurasjonen er allerede levert og krever vanligvis ikke endringer under første oppsett. Du trenger kun å konfigurere den hvis du må tilpasse backend-tilkoblingen.

Hvis du må endre dashboard-konfigurasjonen (f.eks. for multi-instans distribusjoner), se dashboardets dokumentasjon.

Velg webserver og følg tilsvarende distribusjonstrinn.

Deploy til nginx¶

Hvis du fulgte nginx-oppsettet, peker serverblokken allerede på din dashboard-mappe og ingen kopiering er nødvendig.

1. Bekreft stien
2. Åpne /etc/nginx/conf.d/digna.conf

3. Verifiser at root peker til din utpakkede dashboard-mappe

4. Sørg for at mappen er lesbar

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

5. Reload nginx

   sudo nginx -t
   sudo systemctl reload nginx
   

6. Test installasjonen

7. Åpne nettleseren
8. Gå til http://localhost (eller din konfigurerte URL)
9. Du skal se digna-dashboardets innloggingsside

Deploy til Apache httpd¶

1. Kopier dashboardet til dokumentroten

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

2. Legg til omskrivingsreglene

Opprett en .htaccess-fil inne i den deployerte mappen slik at dashboard-ruter overlever en oppfriskning i nettleseren:

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

Lim inn følgende:

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. Restart Apache

   sudo systemctl restart apache2
   

   sudo systemctl restart httpd
   

2. Åpne dashboardet

3. Åpne nettleseren
4. Gå til http://localhost/digna
5. Du skal se digna-dashboardets innloggingsside

Steg 2: SELinux (kun RHEL-familien)¶

På RHEL, Rocky, AlmaLinux og Fedora er SELinux som regel enforcing og vil blokkere webserveren fra å lese filer utenfor forventede steder. Sjekk om det er aktivt:

getenforce

Hvis resultatet er Enforcing og du serverer dashboardet fra /opt/digna/dashboard, merk katalogen slik at webserveren kan lese den:

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

Kjøre digna som en systemd-tjeneste¶

Hvorfor kjøre digna som en tjeneste?¶

Å kjøre digna-backend som en systemd-tjeneste sikrer at den:

• Starter automatisk når maskinen boot-er
• Kjører i bakgrunnen uten et åpent terminalvindu
• Starter på nytt automatisk hvis den krasjer
• Kan administreres via systemctl, standard Linux-tjenestebehandler

Filer for tjenesteadministrasjon¶

Alle nødvendige filer ligger i digna-installasjonskatalogen under: bin/

Følgende shell-skript er tilgjengelige:

• install_service.sh — registrerer digna hos systemd
• uninstall_service.sh — fjerner registreringen
• start_service.sh — starter den registrerte tjenesten
• stop_service.sh — stopper den kjørende tjenesten

Gjøre skriptene kjørbare¶

Utpakking bevarer kanskje ikke kjørbar-bit. Før første bruk:

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

Installere tjenesten¶

1. Åpne et terminalvindu

2. Gå til bin-mappen

   cd /opt/digna/bin
   

3. Kjør installasjonsskriptet

   sudo ./install_service.sh
   

digna-serveren er nå registrert hos systemd med automatisk oppstart aktivert. Tjenesten starter ikke umiddelbart — se neste seksjon for å starte den.

Starte og stoppe tjenesten¶

For å starte tjenesten¶

1. Åpne et terminalvindu
2. Gå til /opt/digna/bin
3. Kjør:

   sudo ./start_service.sh
   

For å stoppe tjenesten¶

1. Åpne et terminalvindu
2. Gå til /opt/digna/bin
3. Kjør:

   sudo ./stop_service.sh
   

Administrere tjenesten med systemctl¶

Når den er registrert, kan tjenesten også kontrolleres med standard systemd-kommandoer fra hvilken som helst katalog:

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

Verifisere tjenesten¶

For å bekrefte at tjenesten er registrert og kjører:

systemctl is-enabled digna
systemctl is-active digna

enabled betyr at tjenesten starter ved boot; active betyr at den kjører nå.

Vise tjenestelogger¶

systemd fanger opp alt backend skriver til konsollen. For å lese det:

sudo journalctl -u digna -n 100

For å følge loggen i sanntid mens du reproduserer et problem:

sudo journalctl -u digna -f

Flytte tjenesten til en ny katalog¶

Enhetsfilen lagrer den absolutte stien til den kjørbare filen, så flytting av installasjonen krever ny registrering av tjenesten:

1. Avinstaller den nåværende tjenesten

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

2. Flytt applikasjonsfilene

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

3. Installer tjenesten på nytt

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

4. Start tjenesten

   sudo ./start_service.sh
   

Avinstallere tjenesten¶

1. Stopp den kjørende tjenesten

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

2. Avinstaller tjenesten

   sudo ./uninstall_service.sh
   

digna-serveren er nå avregistrert fra systemd.

Oppgradere til en ny utgivelse¶

Før du oppgraderer¶

Det er obligatorisk å ta backup av digna-repositoriet

Før du oppgraderer digna, ta backup av repositoriet (PostgreSQL) for å beskytte mot datatap. En backup sikrer at du kan gjenopprette hvis oppgraderingen møter uventede problemer.

For å lage en backup fra shell:

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

Oppgraderingsprosess¶

Steg 1: Stopp digna-tjenesten¶

Hvis digna kjører som en systemd-tjeneste, stopp den først:

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

Hvis digna kjører i forgrunnen, trykk Ctrl + C i terminalvinduet der den kjører.

Steg 2: Backup av nåværende backend-installasjon¶

I din digna-installasjonsmappe:

cd /opt/digna
sudo mv digna digna_old

sudo mv dashboard dashboard_old

Steg 3: Pakk ut og distribuer ny versjon¶

1. Pakk ut den nye digna-installasjons ZIP-filen
2. Kopier den nye digna-kjørbare og dashboard-mappen til installasjonskatalogen din
3. Gjenopprett kjørbar-bit og eierskap til tjenestekontoen:

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

Steg 4: Gjenopprett konfigurasjonsfiler¶

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

Steg 5: Oppgrader repositories-skjemaet¶

Gå til din digna-installasjonsmappe og kjør:

cd /opt/digna
./digna repo upgrade

Dette oppdaterer PostgreSQL-skjemaet til nyeste versjon samtidig som alle eksisterende data bevares.

Steg 6: Start tjenestene på nytt¶

Hvis du kjører som en systemd-tjeneste:

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

Hvis du kjører manuelt, start serveren på nytt:

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

Hvis du bruker nginx eller Apache, last inn webserveren på nytt:

sudo systemctl reload nginx

sudo systemctl restart apache2

På RHEL-familien, re-apply SELinux-labeling hvis dashboard-katalogen ble erstattet:

sudo restorecon -Rv /opt/digna/dashboard

Steg 7: Verifiser oppgraderingen¶

1. Åpne digna-dashboardet
2. Bekreft at grensesnittet laster riktig
3. Sjekk serverloggene for eventuelle feil:

sudo journalctl -u digna -n 100