# Self Hosting Seq for ASP.NET Logging

<datetime class="hidden">2024-08-28T09:37</datetime>

<!--category-- ASP.NET, Seq, Serilog, Docker -->
# Introduction

Seq est une application qui vous permet de visualiser et d’analyser les logs. C’est un excellent outil de débugging et de surveillance de votre application . Dans ce post, j’aborderai la façon dont je mets en place Seq pour afficher mon ASPM SK4NET Application Core.
Ne peut jamais avoir trop de tableaux de bord :)

![SeqDashboard](seqdashboard.png)

[TOC]

# Établissement de Seq

Seq présente plusieurs saveurs. Vous pouvez utiliser la version nulle ou l’héberger par vous-même. J’ai choisi d’en héberger par moi-même car je voulais garder mes registres privés .

Premièrement, j’ai commencé par visiter le site Web de Seq et trouver [Instructions d'installation de Docker](https://docs.datalust.co/docs/getting-started-with-docker).

## À l'échelle locale

Pour fonctionner localement, vous devez d'abord obtenir un mot de passe haché. Vous pouvez le faire en exécutant la commande suivante:

```bash
echo '<password>' | docker run --rm -i datalust/seq config hash
```

Pour le faire localement, vous pouvez utiliser la commande suivante:

```bash
docker run --name seq -d --restart unless-stopped -e ACCEPT_EULA=Y -e SEQ_FIRSTRUN_ADMINPASSWORDHASH=<hashfromabove> -v C:\seq:/data -p 5443:443 -p 45341:45341 -p 5341:5341 -p 82:80 datalust/seq

```

Sur ma machine locale Ubuntu, j’ai fait de ce script sh:

```shell
#!/bin/bash
PH=$(echo 'Abc1234!' | docker run --rm -i datalust/seq config hash)

mkdir -p /mnt/seq
chmod 777 /mnt/seq

docker run \
  --name seq \
  -d \
  --restart unless-stopped \
  -e ACCEPT_EULA=Y \
  -e SEQ_FIRSTRUN_ADMINPASSWORDHASH="$PH" \
  -v /mnt/seq:/data \
  -p 5443:443 \
  -p 45341:45341 \
  -p 5341:5341 \
  -p 82:80 \
  datalust/seq
```

Ensuite,

```shell
chmod +x seq.sh
./seq.sh
```

Cela vous fera monter et marcher puis aller à `http://localhost:82` / `http://<machineip>:82` pour voir votre seq install (password d'administrateur par défaut est celui que vous avez saisi <password> ci-dessus.

## Dans Docker

J’ai ajouté seq à mon fichier de composition Docker comme suit:

```docker
  seq:
    image: datalust/seq
    container_name: seq
    restart: unless-stopped
    environment:
      ACCEPT_EULA: "Y"
      SEQ_FIRSTRUN_ADMINPASSWORDHASH: ${SEQ_DEFAULT_HASH}
    volumes:
      - /mnt/seq:/data
    networks:
      - app_network
```

Notez que j'ai un répertoire appelé `/mnt/seq` (pour windowsM SK1 utiliser un chemin de fenêtres). C'est là où les registres seront stockés .

J'ai également un `SEQ_DEFAULT_HASH` variable environnementale qui est le mot de passe achevé pour l'utilisateur administratif dans mon fichier .env.

# Configuration de l'ASP.NET Core

Comme je l'utilise [Serilog](https://serilog.net/) pour mon enregistrement il'est en fait assez facile à installer Seq. Il a même des documents sur la façon de le faire [ici](https://docs.datalust.co/docs/using-serilog).

En principe, vous ajoutez simplement le réservoir à votre projet:

```shell
dotnet add package Serilog.Sinks.Seq
```

Je préfère utiliser `appsettings.json` pour ma configuration, je n’ai que la configuration 'standard' dans mon ordinateur `Program.cs`:

```csharp
builder.Host.UseSerilog((context, configuration) =>
{
    configuration.ReadFrom.Configuration(context.Configuration);
    Serilog.Debugging.SelfLog.Enable(Console.Error);
    Console.WriteLine($"Serilog Minimum Level: {configuration.MinimumLevel.ToString()}");
});
```

Ensuite, dans mon `appsettings.jsonM SK2 j'ai cette configuration

```json
  "Serilog": {
    "Using": ["Serilog.Sinks.Console", "Serilog.Sinks.File", "Serilog.Sinks.Seq"],
    "MinimumLevel": "Warning",
    "WriteTo": [
        {
          "Name": "Seq",
          "Args":
          {
            "serverUrl": "http://seq:5341",
            "apiKey": ""
          }
        },
      {
        "Name": "Console"
      },
      {
        "Name": "File",
        "Args": {
          "path": "logs/applog-.txt",
          "rollingInterval": "Day"
        }
      }

    ],
    "Enrich": ["FromLogContext", "WithMachineName"],
    "Properties": {
      "ApplicationName": "mostlylucid"
    }
  }

```

Vous verrez que j’ai un `serverUrl` de `http://seq:5341`. C'est parce que j'ai le seq en train dans un conteneur de docker appelé `seq` et il's sur le port `5341`. Si vous l'utilisez localement, vous pouvez utiliser `http://localhost:5341`.
J'utilise également la clé API pour pouvoir utiliser cette clé pour spécifier le niveau de log dynamiquement (vous pouvez configurer une clé pour accepter seulement un certain niveau de messages de log).

Vous l’établissez dans votre exemple seq en allant à `http://<machine>:82` et en cliquant sur le cog des paramètres en haut à droite. Ensuite, cliquez sur `API Keys` et ajouter une nouvelle clé. Vous pouvez ensuite utiliser cette clé dans votre `appsettings.json` fichier.

![Seq](seqapikey.png)

# Docker Compose

Maintenant que nous avons cette mise en place, nous devons configurer notre application ASP.NET pour prendre une clé `.env` fichier pour stocker mes secrets.

```dotenv
SEQ_DEFAULT_HASH="<adminpasswordhash>"
SEQ_API_KEY="<apikey>"
```

Ensuite, dans mon fichier docker compose, je spécifie que la valeur doit être injectée comme variable environnementale dans ma application ASP.NET:

```docker
services:
  mostlylucid:
    image: scottgal/mostlylucid:latest
    ports:
      - 8080:8080
    restart: always
    labels:
        - "com.centurylinklabs.watchtower.enable=true"
    env_file:
      - .env
    environment:
      - Auth__GoogleClientId=${AUTH_GOOGLECLIENTID}
      - Auth__GoogleClientSecret=${AUTH_GOOGLECLIENTSECRET}
      - Auth__AdminUserGoogleId=${AUTH_ADMINUSERGOOGLEID}
      - SmtpSettings__UserName=${SMTPSETTINGS_USERNAME}
      - SmtpSettings__Password=${SMTPSETTINGS_PASSWORD}
      - Analytics__UmamiPath=${ANALYTICS_UMAMIPATH}
      - Analytics__WebsiteId=${ANALYTICS_WEBSITEID}
      - ConnectionStrings__DefaultConnection=${POSTGRES_CONNECTIONSTRING}
      - TranslateService__ServiceIPs=${EASYNMT_IPS}
      - Serilog__WriteTo__0__Args__apiKey=${SEQ_API_KEY}
    volumes:
      - /mnt/imagecache:/app/wwwroot/cache
      - /mnt/markdown/comments:/app/Markdown/comments
      - /mnt/logs:/app/logs
    networks:
      - app_network
```

Notez que le `Serilog__WriteTo__0__Args__apiKey` est fixé à la valeur de `SEQ_API_KEY` de la `.env` Le '0' est l'index de la `WriteTo` dans le tableau `appsettings.json` fichier.

# Caddy

Note pour Seq et ma application ASP.NET I' j’ai spécifié qu’elles appartiennent à mon `app_network` réseau. C'est parce que je utilise Caddy comme proxy inverse et qu'il se trouve sur le même réseau.

```caddy
{
    email scott.galloway@gmail.com
}
seq.mostlylucid.net
{
   reverse_proxy seq:80
}

http://seq.mostlylucid.net
{
   redir https://{host}{uri}
}
```

Celle-ci est donc en mesure de cartographier `seq.mostlylucid.net` à mon seq instance.

# Conclusion

Seq est un excellent outil pour l'enregistrement et la surveillance de votre application. Il ' est facile à mettre en place et à utiliser et s'intègre bien avec Serilog. IM SK3 j'ai trouvé qu'il était inestimable dans le débugging de mes applications, et je suis certain que vous l'aurez aussiMSC5