Gezondheidsorganisaties hebben steeds meer geautomatiseerde oplossingen nodig om medische beeldgegevens te deidentificeeren.In deze gids leert u hoe u een DICOM-anonymisatie microservice in ASP.NET Core kunt bouwen die DICO-bestanden via HTTP ontvangt, ze anonimiseert met behulp van configurable profielen en de de-identified resultaten terugbrengt.

Tabel van inhoud

Architectuur Overzicht

De microservice volgt een layered architectuur met een duidelijke scheiding van bezorgdheid. de API-laag beheert HTTP-verzoeken en antwoorden via ASP.NET Core-controlers. het servicelaag bevat de zakelijke logica met behulp van de Aspose.Medical Anonymizer. De configuratielager beheerst profielinstellingen en toepassingsopties. optionele componenten omvatten opslag voor logging en quuing voor batchverwerking.

Deze architectuur zorgt voor horizontale scaling, gemakkelijke testen en eenvoudige integratie met ziekenhuisinformatiesystemen en PACS-servers.

Setting Up het project

Begin door een nieuw ASP.NET Core Web API-project te maken en het vereiste pakket te installeren:

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

Configureer het project voor grote bestanden uploaden in 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();

Het implementeren van de Service Layer

Creëren van een interface en implementatie voor de anonimiteitsdienst:

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

Bouw de API Controller

Creëren van een beheerder die bestanden uploaden en geanonimiseerde DICOM-bestanden retourneert:

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

Configurerbare profielen

Laat profielen worden geconfigureerd via appsettings.json:

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

Creëer een configuratieklasse en update de service om te lezen uit instellingen:

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

Beoordelingen van de veiligheid

Bij het uitvoeren van deze service, implementeren deze beveiligingsmaatregelen.

HTTPS mogelijk maken om ervoor te zorgen dat alle communicaties worden gecodeerd tijdens de transit.TLS 1.2 of hoger configureren en HTTP naar Https hersturen.

Implementatie authenticatie met behulp van JWT tokens of API sleutels om toegang tot geautoriseerde klanten te beperken:

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

Vermijd het opslaan van oorspronkelijke bestanden niet versleuteld op de schijf. verwerken van gegevens in het geheugen wanneer mogelijk, en als tijdelijke opslag nodig is, gebruik geencrypteerde volumes.

Een auditlogging mogelijk maken om alle anoniemactiviteiten te volgen, met inbegrip van wie ze heeft gevraagd en wanneer:

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

Performance optimalisatie (performance optimization)

Verschillende technieken kunnen de prestaties verbeteren voor high-throughput scenario’s.

** Gebruik in-site anonymisatie** wanneer u de oorspronkelijke gegevens niet in het geheugen hoeft te bewaren:

anonymizer.AnonymizeInPlace(dcm);

Een parallelle verwerking mogelijk maakt voor batch-operaties:

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

Implementatie verzoek quuing voor zeer grote partijen met behulp van een bericht quue zoals RabbitMQ of Azure Service Bus om de lading spikes te beheren zonder de service te overwinnen.

De conclusie

U heeft nu een volledige ontwerp voor het bouwen van een DICOM-anonymisatie microservice in ASP.NET Core. De service accepteert DICO-bestanden via HTTP, toepast configurabele anonimiseerprofielen met behulp van Aspose.Medical en retourneert de geïdentificeerde bestanden klaar voor onderzoek of delen.

De belangrijkste taken omvatten het gebruik van layered architectuur voor onderhoudbaarheid, de implementatie van configurable profielen voor flexibiliteit, het waarborgen van de service met authenticatie en encryptie en het optimaliseren van prestaties met parallelle verwerking.

Voor de volledige broncode en aanvullende voorbeelden, bezoek de Aspose.Medische documentatieOm het vuur te proberen, Krijg gratis tijdelijke licentie.

More in this category