macOS-installationsguide för digna Release 2026.06¶

Release: 2026.06

Senast uppdaterad: 5 september 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.06¶

Den här releasen för in data-observability-möjligheter direkt i din kod, vilket gör det möjligt för utvecklare att övervaka datakvalitet vid källan. Se release notes för fullständiga detaljer.

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.06-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 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] 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!"

[base] Avsnittet¶

Detta avsnitt 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] Avsnittet¶

Detta avsnitt konfigurerar logghantering:

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

Du bör se en bekräftelse på att anslutningen är etablerad (själva repositoriet har ännu inte initialiserats).

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

Steg 4: Installera repository-schemat¶

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 admin-anvä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 värdnamn/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

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¶

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.

Att skapa en backup av digna-repositoriet är obligatoriskt

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

Uppgraderingsprocess¶

Steg 1: Stoppa digna-tjänsten¶

Om digna körs som 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å mapparna i din nuvarande installation i digna-installationskatalogen, så att den nya releasen kan distribueras vid sidan av dem:

cd /opt/digna
mv dignabackend dignabackend_old

mv dignacli dignacli_old

mv dashboard dashboard_old

Steg 3: Extrahera och distribuera ny version¶

1. Extrahera den nya digna-installations-ZIP-filen
2. Kopiera den nya digna-körbara och dashboard-mappen till din installationskatalog
3. Återställ exekveringsbiten och, om nödvändigt, ta 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

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

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:

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

./digna license check

Steg 8: Uppgradera repository-schemat¶

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