Az egészségügyi szervezeteknek egyre inkább automatizált megoldásokra van szükségük az orvosi képadatok de-identifikálására.Ebben az útmutatóban megtudhatja, hogyan kell létrehozni egy DICOM névtelenítő mikroszolgálatot az ASP.NET Core-ban, amely a DICUM fájlokat a HTTP-n keresztül kapja, a konfigurálható profilok használatával anonimizálja őket, és visszaadja az azonosított eredményeket.

Tartalmak táblája

Építészeti áttekintés

A mikroszolgáltatás követ egy rétegű építészet egyértelmű elkülönítése az aggodalmak. Az API rétege kezeli a HTTP kérések és válaszok keresztül ASP.NET Core vezérlőket. A szolgáltatási rétek tartalmazza az üzleti logika használatával az Aspose.Medical Anonymizer. a konfigurációs réten kezelése profil beállítások és alkalmazási lehetőségek. Opcionális komponensek közé tartozik tárolás a bejelentkezés és a quuing a csomagfeldolgozás.

Ez az építészet lehetővé teszi a horizontális méretezés, könnyű tesztelés és a kórházi információs rendszerekkel és PACS szerverekkel való egyszerű integrációt.

A projekt beállítása

Kezdjük egy új ASP.NET Core Web API projekt létrehozásával és a szükséges csomag telepítésével:

dotnet new webapi -n DicomAnonymizationService
cd DicomAnonymizationService
dotnet add package Aspose.Medical

Állítsa be a projektet a nagy fájl-felvételekhez Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Configure for large DICOM files
builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 500_000_000; // 500MB
});

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 500_000_000;
});

// Register services
builder.Services.AddScoped<IDicomAnonymizationService, DicomAnonymizationService>();
builder.Services.AddControllers();

var app = builder.Build();

app.MapControllers();
app.Run();

A szolgáltatási réteg végrehajtása

Hozzon létre egy interfészet és végrehajtást az anonimizációs szolgáltatáshoz:

using Aspose.Medical.Dicom;
using Aspose.Medical.Dicom.Anonymization;

public interface IDicomAnonymizationService
{
    Task<byte[]> AnonymizeAsync(Stream inputStream, string? profileName = null);
    Task<byte[]> AnonymizeAsync(byte[] inputBytes, string? profileName = null);
}

public class DicomAnonymizationService : IDicomAnonymizationService
{
    private readonly ILogger<DicomAnonymizationService> _logger;
    private readonly Dictionary<string, ConfidentialityProfileOptions> _profiles;

    public DicomAnonymizationService(ILogger<DicomAnonymizationService> logger)
    {
        _logger = logger;
        _profiles = new Dictionary<string, ConfidentialityProfileOptions>
        {
            ["basic"] = ConfidentialityProfileOptions.BasicProfile,
            ["research"] = ConfidentialityProfileOptions.BasicProfile | 
                          ConfidentialityProfileOptions.RetainPatientChars,
            ["internal"] = ConfidentialityProfileOptions.RetainUIDs | 
                          ConfidentialityProfileOptions.RetainDeviceIdent,
            ["clean"] = ConfidentialityProfileOptions.CleanGraph | 
                       ConfidentialityProfileOptions.CleanDesc
        };
    }

    public async Task<byte[]> AnonymizeAsync(Stream inputStream, string? profileName = null)
    {
        using var memoryStream = new MemoryStream();
        await inputStream.CopyToAsync(memoryStream);
        return await AnonymizeAsync(memoryStream.ToArray(), profileName);
    }

    public Task<byte[]> AnonymizeAsync(byte[] inputBytes, string? profileName = null)
    {
        return Task.Run(() =>
        {
            // Create anonymizer with selected profile
            Anonymizer anonymizer = CreateAnonymizer(profileName);

            // Load DICOM from bytes
            using var inputStream = new MemoryStream(inputBytes);
            DicomFile dcm = DicomFile.Open(inputStream);

            // Anonymize
            DicomFile anonymizedDcm = anonymizer.Anonymize(dcm);

            // Write to output stream
            using var outputStream = new MemoryStream();
            anonymizedDcm.Save(outputStream);

            _logger.LogInformation("Anonymized DICOM file using profile: {Profile}", 
                profileName ?? "default");

            return outputStream.ToArray();
        });
    }

    private Anonymizer CreateAnonymizer(string? profileName)
    {
        if (string.IsNullOrEmpty(profileName) || !_profiles.ContainsKey(profileName.ToLower()))
        {
            return new Anonymizer();
        }

        var options = _profiles[profileName.ToLower()];
        var profile = ConfidentialityProfile.CreateDefault(options);
        return new Anonymizer(profile);
    }
}

Az API vezérlő építése

Hozzon létre egy vezérlőt, amely kezeli a fájlfelvételt és visszaadja az anonimizált DICOM-fájljait:

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class AnonymizeController : ControllerBase
{
    private readonly IDicomAnonymizationService _anonymizationService;
    private readonly ILogger<AnonymizeController> _logger;

    public AnonymizeController(
        IDicomAnonymizationService anonymizationService,
        ILogger<AnonymizeController> logger)
    {
        _anonymizationService = anonymizationService;
        _logger = logger;
    }

    /// <summary>
    /// Anonymize a single DICOM file
    /// </summary>
    [HttpPost]
    [RequestSizeLimit(500_000_000)]
    public async Task<IActionResult> AnonymizeFile(
        IFormFile file,
        [FromQuery] string? profile = null)
    {
        if (file == null || file.Length == 0)
        {
            return BadRequest("No file uploaded");
        }

        try
        {
            _logger.LogInformation("Processing file: {FileName}, Size: {Size}", 
                file.FileName, file.Length);

            using var stream = file.OpenReadStream();
            byte[] anonymizedBytes = await _anonymizationService.AnonymizeAsync(stream, profile);

            string outputFileName = $"anonymized_{file.FileName}";
            return File(anonymizedBytes, "application/dicom", outputFileName);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error anonymizing file: {FileName}", file.FileName);
            return StatusCode(500, $"Anonymization failed: {ex.Message}");
        }
    }

    /// <summary>
    /// Anonymize DICOM data from request body
    /// </summary>
    [HttpPost("stream")]
    [RequestSizeLimit(500_000_000)]
    public async Task<IActionResult> AnonymizeStream([FromQuery] string? profile = null)
    {
        try
        {
            byte[] anonymizedBytes = await _anonymizationService.AnonymizeAsync(
                Request.Body, profile);

            return File(anonymizedBytes, "application/dicom", "anonymized.dcm");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error anonymizing stream");
            return StatusCode(500, $"Anonymization failed: {ex.Message}");
        }
    }

    /// <summary>
    /// List available anonymization profiles
    /// </summary>
    [HttpGet("profiles")]
    public IActionResult GetProfiles()
    {
        var profiles = new[]
        {
            new { name = "basic", description = "Standard anonymization removing most identifiers" },
            new { name = "research", description = "Retains patient characteristics for research" },
            new { name = "internal", description = "Retains UIDs for internal tracking" },
            new { name = "clean", description = "Removes burned-in graphics and descriptions" }
        };

        return Ok(profiles);
    }
}

Konfigurálható profilok

Lehetővé teszi a profilok konfigurálását a appsettings.json:

{
  "AnonymizationProfiles": {
    "default": "basic",
    "profiles": {
      "basic": ["BasicProfile"],
      "research": ["BasicProfile", "RetainPatientChars"],
      "internal": ["RetainUIDs", "RetainDeviceIdent"],
      "clean": ["CleanGraph", "CleanDesc"],
      "maximum": ["BasicProfile", "CleanGraph", "CleanDesc"]
    }
  }
}

Hozzon létre egy konfigurációs osztályot, és frissítse a szolgáltatást a beállításokból való olvasáshoz:

public class AnonymizationProfileOptions
{
    public string Default { get; set; } = "basic";
    public Dictionary<string, string[]> Profiles { get; set; } = new();
}

// In Program.cs
builder.Services.Configure<AnonymizationProfileOptions>(
    builder.Configuration.GetSection("AnonymizationProfiles"));

Biztonsági megfontolások

A szolgáltatás végrehajtása során ezeket a biztonsági intézkedéseket alkalmazzák.

HTTPS engedélyezése annak biztosítására, hogy az összes kommunikáció titkosítva legyen a tranzit során. Állítsa be a TLS 1.2 vagy annál magasabb szintet, és HTTP-t átirányítson a https-re.

Implementációs hitelesítés JWT tokenek vagy API kulcsok használatával, hogy korlátozzák a hozzáférést az engedélyezett ügyfelek:

[Authorize]
[ApiController]
[Route("api/[controller]")]
public class AnonymizeController : ControllerBase
{
    // Controller code...
}

Ne tárolja az eredeti fájlokat titkosítva a lemezre.Megfeldolgozza a memóriájában lévő adatokat, ha lehetséges, és ha ideiglenes tárolásra van szükség, használja a titkolt mennyiségeket.

A könyvvizsgálati bejelentkezés engedélyezése az összes névtelenítési művelet nyomon követésére, beleértve azt is, hogy ki kérte őket, és amikor:

_logger.LogInformation(
    "Anonymization completed - User: {User}, Profile: {Profile}, FileSize: {Size}",
    User.Identity?.Name, profile, file.Length);

A teljesítmény optimalizálása

Számos technika javíthatja a teljesítményt a nagy teljesítményű forgatókönyvekhez.

A helyszíni névtelenítés használata, amikor az eredeti adatokat nem kell a memóriában tárolni:

anonymizer.AnonymizeInPlace(dcm);

A párhuzamos feldolgozás engedélyezése a csomagkezelési műveletekhez:

[HttpPost("batch")]
public async Task<IActionResult> AnonymizeBatch(List<IFormFile> files)
{
    var results = await Parallel.ForEachAsync(
        files,
        new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
        async (file, ct) =>
        {
            using var stream = file.OpenReadStream();
            return await _anonymizationService.AnonymizeAsync(stream);
        });

    // Return results...
}

**A végrehajtás kérelmezése a nagyon nagy csomópontokhoz olyan üzenetcsomó használatával, mint a RabbitMQ vagy az Azure Service Bus, hogy a terhelés csúcsát a szolgáltatás túlterhelése nélkül kezeljék.

A következtetés

Most már van egy teljes terv, hogy építsen egy DICOM névtelenítés mikroszolgálat az ASP.NET Core. A szolgáltatás elfogadja a DIKOM fájlokat a HTTP-n keresztül, alkalmazza a konfigurálható anonimizációs profilok segítségével Aspose.Medical, és visszatér de-azonosított fák készen a kutatás vagy a megosztás.

A kulcsfontosságú intézkedések közé tartozik a karbantartás érdekében réteges építészet használata, a rugalmasság érdekében konfigurálható profilok végrehajtása, az hitelesítéssel és titkosítással ellátott szolgáltatás biztosítása, valamint a teljesítmény optimalizálása párhuzamos feldolgozással.

A teljes forráskódhoz és további példákhoz látogasson el a Gyógyszertár - orvosi dokumentációAhhoz, hogy megpróbálja a tűz, Ingyenes ideiglenes licenc.

More in this category