macOS-installationsguide för digna Release 2026.11¶

Release: 2026.11

Senast uppdaterad: 7 november 2026

Innehållsförteckning¶

1. Introduktion
2. Systemkrav
3. Förberedelser före installation
4. Förbered PostgreSQL-servern
5. Webbserverkonfiguration
6. Initial installation
7. Backend-konfiguration
8. Dashboard-konfiguration
9. Köra digna som bakgrundstjänst
10. Uppgradera till en ny release

Introduktion¶

Om digna¶

digna är en omfattande AI-driven plattform utformad för att optimera datakvalitetshantering i olika data-miljöer såsom datalager, datasjöar och lakehouses. Byggd för hög skalbarhet och anpassningsförmåga, digna hanterar moderna datautmaningar genom automatisering, realtidsövervakning och avvikelsedetektion.

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 som körs på en webbserver och ger ett användarvänligt sätt att interagera med digna-plattformen och visualisera datakvalitetsmått.

Nytt i Release 2026.11¶

Denna release lägger till digna Data Reconciliation, digna Agentic med digna MCP Server samt digna Engine, som kan profilera data inuti digna och kontrollera referentiell integritet mellan olika databastekniker. Se versionsanteckningarna för fullständiga detaljer.

För en installation medför releasen en ny mekanism för repositorymigreringar, en valfri [duckdb]-sektion i config.toml för digna Engine och en ny licensfil. Uppgraderingsavsnittet går igenom var och en av dem.

Letar du efter Windows eller Linux?¶

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

Systemkrav¶

Innan du påbörjar installationen, se till att ditt system uppfyller följande minimikrav:

Alternativ för databasinstallation¶

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

Om du installerar PostgreSQL på samma maskin som digna:

Kontrollera din arkitektur¶

Flera sökvägar i denna guide skiljer sig mellan Apple Silicon och Intel-Mac. För att kontrollera vilken arkitektur du har, öppna Terminal och kör:

uname -m

• arm64 — Apple Silicon. Homebrew installeras till /opt/homebrew.
• x86_64 — Intel. Homebrew installeras till /usr/local.

Förberedelser före installation¶

Innan du installerar digna, säkerställ att tre nyckelförutsättningar är på plats:

1. Homebrew – paketchefen som används för att installera komponenterna nedan
2. PostgreSQL Server – för att lagra beräknade mått och prestandadata
3. 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.

Installera Homebrew¶

Homebrew är standardpakethanteraren för macOS och används i hela denna guide för att installera PostgreSQL och nginx.

Steg 1: Kontrollera om Homebrew redan är installerat¶

Öppna Terminal (tryck Cmd + Space, skriv Terminal, tryck Enter) och kör:

brew --version

Om ett versionsnummer returneras, hoppa till avsnittet Förbered PostgreSQL-servern.

Steg 2: Installera Homebrew¶

Om kommandot inte hittades, installera Homebrew genom att följa instruktionerna på officiella Homebrew-sajten. Installationsprogrammet installerar även Xcode Command Line Tools om de inte redan finns.

Steg 3: Lägg till Homebrew i din PATH¶

På Apple Silicon skriver installatören ut två kommandon för att lägga till Homebrew i din shell-miljö. Kör dem enligt instruktionerna och bekräfta sedan:

brew --prefix

Detta bör skriva ut /opt/homebrew på Apple Silicon eller /usr/local på Intel.

Förbered PostgreSQL-servern¶

Om du redan har PostgreSQL¶

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

Installationsalternativ¶

macOS erbjuder två enkla sätt att installera PostgreSQL. Välj ett:

• Homebrew — kommandoradsinstallation, rekommenderas för serverdistributioner
• Postgres.app — grafisk installation, bekvämt för lokal utvärdering

Installera PostgreSQL med Homebrew¶

Steg 1: Installera PostgreSQL-formeln¶

brew install postgresql@16

Steg 2: Lägg till PostgreSQL i din PATH¶

Versionerade PostgreSQL-formler är keg-only, vilket innebär att Homebrew inte länkar deras kommandon till din PATH automatiskt. Lägg till dem själv:

echo 'export PATH="'$(brew --prefix)'/opt/postgresql@16/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Steg 3: Starta PostgreSQL-tjänsten¶

brew services start postgresql@16

Detta startar PostgreSQL omedelbart och konfigurerar det för att starta automatiskt när du loggar in.

Steg 4: Verifiera installationen¶

psql --version

Du bör se PostgreSQL-versionen om installationen lyckades.

Steg 5: Anslut till servern¶

psql postgres

Steg 6: Bekräfta porten¶

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

psql postgres -c "SHOW port;"

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

Installera PostgreSQL med Postgres.app¶

Om du föredrar en grafisk installation:

1. Ladda ner Postgres.app och dra den till din Applications-mapp
2. Öppna appen och klicka Initialize för att skapa en ny server
3. Följ appens instruktioner för att lägga till dess kommandoradsverktyg i din PATH
4. Verifiera installationen:

psql --version

Postgres.app skapar också en superuser med namnet efter ditt macOS-konto.

Webbserverkonfiguration¶

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

• nginx — installerat via Homebrew, rekommenderas
• Apache httpd — inkluderat i macOS

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

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

• Fallback för single-page application, så att uppdatering av en dashboard-URL inte ger 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¶

brew install nginx

Starta nginx¶

brew services start nginx

Verifiera installationen¶

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

Konfigurera en site för dashboarden¶

Homebrews nginx-konfiguration inkluderar alla filer i dess servers-katalog. Skapa en dedikerad konfigurationsfil för digna där:

nano $(brew --prefix)/etc/nginx/servers/digna.conf

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

server {
    listen       8080;
    server_name  localhost;

    root   /path/to/digna/dashboard;
    index  index.html;

    # Servera Markdown-filer med korrekt MIME-typ.
    types {
        text/markdown  md;
    }

    # Fallback för single-page-application: okända sökvägar returnerar index.html
    # istället för en 404, så dashboard-rutter överlever en webbläsaruppdatering.
    location / {
        try_files $uri $uri/ /index.html;
    }
}

Tillämpa konfigurationen¶

Testa syntaxen i konfigurationen och ladda om nginx:

nginx -t
brew services restart nginx

Apache httpd-inställning¶

Översikt¶

macOS inkluderar Apache httpd, så ingen installation krävs. Den är som standard inaktiverad.

Starta Apache¶

sudo apachectl start

Verifiera installationen¶

1. Öppna din webbläsare
2. Navigera till http://localhost
3. Du bör se meddelandet "It works!"

Obligatoriskt: Aktivera mod_rewrite¶

Dashboarden kräver URL-omskrivning. Öppna Apache-konfigurationen:

sudo nano /etc/apache2/httpd.conf

Hitta följande rad och ta bort inledande # för att avkommentera den:

LoadModule rewrite_module libexec/apache2/mod_rewrite.so

Obligatoriskt: Tillåt .htaccess-överriding¶

I samma fil, lokalisera <Directory "/Library/WebServer/Documents">-blocket och ändra:

AllowOverride None

till:

AllowOverride All

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

Fortfarande i httpd.conf, 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 om Apache:

sudo apachectl configtest
sudo apachectl restart

Initial installation¶

Steg 1: Skapa digna-repositoriet¶

digna-repositoriet lagrar alla mått som beräknas av digna. Det fungerar som den centrala databasen för analytiska och prestandadata.

Skapa repository-schema och användare¶

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

Ersätt 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 Terminal i ett steg:

psql postgres

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

Steg 2: Extrahera digna-installationspaketet¶

1. Lokalisera digna-installationsfilen (ZIP) som tillhandahållits
2. Extrahera den till önskad installationsplats — till exempel /opt/digna eller ~/digna
3. Efter extraktion bör du se följande objekt:
4. dashboard/ — Webbgränssnittet
5. digna — Huvudkörbar fil (backend + CLI kombinerat)

För att extrahera från Terminal:

unzip digna-2026.11-macos.zip -d /opt/digna

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

Beroende på hur arkivet överfördes kan exekveringsbiten ha försvunnit vid extraktion. Sätt den explicit:

cd /opt/digna
chmod +x digna

Om macOS blockerar applikationen¶

Filer som laddats ner via webbläsare eller e-postklienter taggas med ett karantänattribut. Om macOS rapporterar att appen "cannot be opened because the developer cannot be verified", ta bort attributet från installationskatalogen:

xattr -dr com.apple.quarantine /opt/digna

Alternativt, öppna System Settings → Privacy & Security, hitta det blockerade objektet nära botten av sidan och klicka Open Anyway.

Steg 3: Installera licensfilen¶

1. Lokalisera license.toml-filen som tillhandahållits
2. Kopiera den till rotkatalogen 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 digital signatur. Ändra inte denna fil — alla ändringar gör den ogiltig.

Katalogstruktur efter installation:

/opt/digna/
├── config.toml         (konfigurationsfil)
├── license.toml        (DIN LICENSFIL - kopiera hit)
├── digna               (huvudkörbar fil)
├── bin/                (skript för tjänstehantering)
└── dashboard/          (webbgränssnitt)
    └── (dashboard-filer)

Backend-konfiguration¶

Steg 1: Skapa och redigera konfigurationsfilen¶

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

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

Plats: /opt/digna/config.toml

Öppna config.toml i en textredigerare och konfigurera varje avsnitt nedan.

[app] Avsnittet¶

Detta avsnitt konfigurerar cross-origin resource sharing (CORS) mellan dashboarden och backend:

[app]
DIGNA_APP_CORS_ALLOW_ORIGINS = ["http://localhost:5173"]
DIGNA_APP_CORS_ALLOW_CREDENTIALS = true

[repo] Avsnittet¶

Detta avsnitt 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!"
DIGNA_REPO_SSLMODE = "prefer"
DIGNA_REPO_NUM_CONNS = 16

[base] Avsnittet¶

Detta avsnitt innehåller säkerhets-, cookie- och inspektionsinställningar:

[base]
DIGNA_FERNET_KEY = "DU4a0yJ-OqvbKCL4hNQn_CsknH-V1vWmHZqBUl-AY44="
DIGNA_COOKIE_DOMAIN = "localhost"
DIGNA_COOKIE_SECURE = false
DIGNA_COOKIE_HTTPONLY = true
DIGNA_TOKEN_EXPIRES_IN = 86400
DIGNA_MAX_WORKERS = 4
DIGNA_FRONTEND_BASEURL = "http://localhost/"
DIGNA_SOURCE_QUERY_TIMEOUT_SEC = 3600
DIGNA_SOURCE_LOGIN_TIMEOUT_SEC = 30

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

Detta avsnitt konfigurerar logghantering:

[logging]
DIGNA_LOGGING_MODE = "INFO"
DIGNA_LOGGING_DIR = "logs"
DIGNA_LOGGING_MAX_FILES = 30

[duckdb] Avsnittet (valfritt)¶

Nytt i Release 2026.11. Denna sektion anger resurserna för digna Engine, som profilerar data inuti digna för databasanslutningar vars profileringsplats är digna Engine, och som kör kontroller av referentiell integritet mellan datakällor på olika databasanslutningar. Se Profileringsplats.

Sektionen är valfri. Utan den gäller standardvärdena nedan.

[duckdb]
DIGNA_DUCKDB_MEMORY_LIMIT_MB = 1024
DIGNA_DUCKDB_TEMP_DIRECTORY = "/opt/digna/tmp"

mkdir -p /opt/digna/tmp

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
 - Template overrides: OK
 - Unknown keys: OK

Overall: OK

Åtgärda allt som rapporteras som FAILED och kör kommandot igen innan du fortsätter. En WARNING under Unknown keys listar nycklar i config.toml som digna inte läser; de har ingen effekt, så ta bort dem eller rätta stavningen. Den fullständiga listan över alternativ finns i CLI-referensen.

Steg 3: Initiera repositoriet¶

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

cd /opt/digna
./digna repo check

På ett nytt schema ansluter kommandot och rapporterar sedan att inget repository är installerat ännu:

Error: No repo installed. Use the 'digna repo upgrade' command to install it.

Vid det här laget är det det förväntade resultatet: det bekräftar att digna når PostgreSQL och schemat. Ett anslutnings- eller autentiseringsfel pekar i stället på sektionen [repo] eller på PostgreSQL-uppsättningen.

echo 'export PATH="/opt/digna:$PATH"' >> ~/.zshrc
source ~/.zshrc

Steg 4: Installera repository-schemat¶

I samma katalog, kör:

./digna repo upgrade

Detta kommando installerar nödvändiga tabeller i repositoryschemat och avslutas med:

✅ Repo schema 'dignarepo' is up to date.

Steg 5: Skapa en administratörsanvändare¶

Administratörsanvändaren skapas direkt mot repositoryschemat, så servern behöver inte köras ännu. Kör i digna-installationskatalogen:

./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 värdnamn/IP (standard 127.0.0.1) - --port — Serverns port (standard 8000)

När servern är igång skriver den ut adressen som den lyssnar på:

Server running on http://127.0.0.1:8082

Dashboard-konfiguration¶

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 distribution steg.

Distribuera till nginx¶

Om du följde avsnittet nginx-inställning, pekar serverblocket redan mot din dashboard-mapp och ingen kopiering krävs.

1. Bekräfta sökvägen
2. Öppna $(brew --prefix)/etc/nginx/servers/digna.conf

3. Verifiera att root pekar på din extraherade dashboard-mapp

4. Se till att mappen är läsbar

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

5. Ladda om nginx

   nginx -t
   brew services restart nginx
   

6. Testa installationen

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

Distribuera till Apache httpd¶

1. Kopiera dashboarden till dokumentroten

   sudo cp -R /opt/digna/dashboard /Library/WebServer/Documents/digna
   

2. Lägg till omskrivningsregler

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

sudo nano /Library/WebServer/Documents/digna/.htaccess

Klistra in följande:

RewriteEngine On
RewriteBase /digna/

# Servera befintliga filer och kataloger som de är.
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]

# Allt annat faller tillbaka till single-page-application-entrén.
RewriteRule ^ index.html [L]

1. Starta om Apache

   sudo apachectl restart
   

2. Nå dashboarden

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

Köra digna som bakgrundstjänst¶

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

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

• Startar automatiskt när maskinen bootar
• Körs i bakgrunden utan öppet Terminal-fönster
• Startas om automatiskt om den kraschar
• Kan hanteras via launchctl, macOS servicehanterare

Filer för tjänstehantering¶

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

Följande shell-skript finns:

• install_service.sh — registrerar digna med launchd
• 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¶

Extraktion kanske inte bevarar exekveringsbiten. Innan första användning:

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

Installera tjänsten¶

1. Öppna Terminal

2. Navigera till bin-mappen

   cd /opt/digna/bin
   

3. Kör installationsskriptet

   sudo ./install_service.sh
   

Digna-servern är nu registrerad i launchd med automatisk uppstart aktiverad. Tjänsten startar inte omedelbart — se nästa avsnitt för att starta den.

Starta och stoppa tjänsten¶

För att starta tjänsten¶

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

   sudo ./start_service.sh
   

För att stoppa tjänsten¶

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

   sudo ./stop_service.sh
   

Verifiera tjänsten¶

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

sudo launchctl list | grep digna

En rad som börjar med ett process-ID indikerar att tjänsten körs. Ett - i första kolumnen betyder att den är registrerad men stoppad.

Flytta tjänsten till en ny katalog¶

launchd lagrar den absoluta sökvägen till den körbara filen, så att flytta installationen kräver omregistrering av tjänsten:

1. Avinstallera nuvarande tjänst

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

2. Flytta applikationsfilerna

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

3. Installera tjänsten på nytt

   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 launchd.

Uppgradera till en ny release¶

Detta avsnitt uppgraderar en installation av Release 2026.06 till Release 2026.11. Om din installation är äldre, läs först Uppgradera från en release före 2026.06.

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 Terminal:

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

Begär licensfilen för Release 2026.11

Release 2026.11 kräver en ny license.toml. Begär den från digna-teamet innan du börjar, och ha den redo för steg 7.

Uppgradera från en release före 2026.06¶

Release 2026.06 medförde tre ändringar som fortfarande gäller när du uppgraderar en äldre installation direkt till 2026.11:

• Endast ODBC. digna når varje källteknik via ODBC. Varje databasanslutning som ännu inte använder ODBC måste läggas om till ODBC efter uppgraderingen; det finns ingen automatisk konvertering. Installera ODBC-drivrutinerna på digna-värden i förväg, se Installera ODBC-drivrutinen på digna-värden, och ha egenskaperna för varje anslutning redo från teknikguiderna. Databricks Legacy-anslutaren finns inte längre; flytta de anslutningarna till Databricks-anslutaren.
• En körbar fil. dignabackend och dignacli ersätts av den enda körbara filen digna, som förenar backend och CLI.
• config.toml. Sektionen [encryption] är obligatorisk, och DIGNA_APP_HOST och DIGNA_APP_PORT läses inte längre: servern hämtar sin adress och port från digna serve. Jämför din fil med Backendkonfiguration.

Stegen nedan anger var en äldre installation behöver något annat. Repositoryuppgraderingen i steg 8 för ett repository från vilken tidigare release som helst direkt till 2026.11.

Uppgraderingsprocess¶

Steg 1: Stoppa digna-tjänsten¶

Om digna körs som en bakgrundstjä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 Terminal-fönster.

Steg 2: Säkerhetskopiera nuvarande installation¶

Byt namn på den körbara filen och dashboard-mappen i din nuvarande installation i digna-installationskatalogen, så att den nya releasen kan distribueras vid sidan av dem:

cd /opt/digna
mv digna digna_old
mv dashboard dashboard_old

Behåll digna_old tills du har verifierat uppgraderingen, och dashboard_old tills du har återställt dina konfigurationsfiler från den (se steg 4). Därefter kan du ta bort båda.

Steg 3: Packa upp och distribuera ny version¶

1. Packa upp den nya digna-installations-ZIP-filen
2. Kopiera den nya körbara filen digna och mappen dashboard till din installationskatalog
3. Återställ exekveringsbiten och ta vid behov bort karantänattributet:

chmod +x /opt/digna/digna
xattr -dr com.apple.quarantine /opt/digna

Steg 4: Återställ dina konfigurationsfiler¶

cp dashboard_old/dashboard_config.toml dashboard/dashboard_config.toml

Release 2026.11 kräver ingen ändring i config.toml: en fil som fungerar med Release 2026.06 fortsätter att fungera. Två ändringar är valfria:

• Lägg till en [duckdb]-sektion om databasanslutningar ska använda digna Engine och dess standardvärden inte passar din värd.
• Utelämna sektionen [app] om en omvänd proxy serverar dashboarden och backend under samma origin.

[[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'

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 (Cmd+Shift+R).

Steg 6: Validera konfigurationen¶

Kontrollera att 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, ta bort nycklarna som listas under Unknown keys och kör kommandot igen innan du fortsätter.

Steg 7: Ersätt licensfilen¶

En licensfil följer normalt med från en release till nästa. Release 2026.11 är ett undantag: den lägger till två licensierade moduler, digna Data Reconciliation och digna Agentic, och en licens som utfärdats före 2026.11 innehåller dem inte. Kopiera den license.toml som digna-teamet tillhandahållit för Release 2026.11 till installationskatalogen och ersätt den gamla:

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

./digna license check

Steg 8: Uppgradera repositoryschemat¶

Kör i din digna-installationskatalog:

cd /opt/digna
./digna repo upgrade

Release 2026.11 hanterar repositoryschemat med versionerade migreringar. Den första uppgraderingen från en tidigare release för schemat till den sista versionen av det tidigare systemet, registrerar den som utgångspunkt och tillämpar sedan migreringarna i Release 2026.11. Den avslutas med:

✅ Baseline migration recorded as applied.
✅ Repo schema 'dignarepo' is up to date.

All befintlig data bevaras. För att när som helst se repositoryts tillstånd, kör ./digna repo check: det listar den senast tillämpade migreringen och eventuella väntande migreringar.

Error: Legacy repo version 3.0.2 installed. Use the 'digna repo upgrade' command to upgrade it.

Steg 9: Starta om tjänsterna¶

Om du kör som bakgrundstjä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, starta om respektive webbserver:

brew services restart nginx

sudo apachectl restart

Steg 10: Verifiera uppgraderingen¶

1. Bekräfta releasen för den nya körbara filen:

   ./digna version
   

   Första raden måste vara Release: 2026.11.

2. Öppna digna-dashboarden och kontrollera att gränssnittet laddas korrekt.

3. Kontrollera serverns utdata och filerna i katalogen logs efter fel.
4. Testa dina databasanslutningar — se Testa en anslutning. Efter en uppgradering från en release före 2026.06, lägg först om varje anslutning som inte redan använde ODBC till ODBC.

För att komma igång med de nya modulerna, se digna Data Reconciliation, Ansluta en AI-agent för digna MCP Server och Profileringsplats för digna Engine.