Sağlık kuruluşları giderek tıbbi görüntü verilerini tespit etmek için otomatik çözümlere ihtiyaç duyar. bu kılavuzda, HTTP aracılığıyla DICOM dosyalarını alıp, yapılandırılabilir profilleri kullanarak anonimleştiren bir **Dicom Anonimleşme Microservice’ı nasıl oluşturacağınızı öğreneceksiniz. sonuna kadar, örnek kaynak kodu ile üretime hazır bir servis mimarisine sahip olacaksınız.

içerik tablosu

Mimarlık Genel Bakış

Microservice, kaygıların açık bir bölünmesi ile bir katmanlı mimari takip eder. API katmanı, ASP.NET Core kontrolörleri aracılığıyla HTTP talepleri ve yanıtları ele alır. Hizmet tabanı, Aspose.Medical Anonymizer’ı kullanarak iş mantığını içerir. Konfigürasyon tabakası, profil ayarlarını ve uygulama seçeneklerini yöneter.

Bu mimarlık, yatay ölçekleme, kolay test ve hastane bilgi sistemleri ve PACS sunucuları ile basit bir entegrasyon sağlar.

Projeyi ayarlayın

Yeni bir ASP.NET Core Web API projesi oluşturarak başlayın ve gerekli paketi yükleyin:

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

Büyük dosya yüklemeleri için projeyi ayarlayın 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();

Hizmet Katmanı Uygulaması

Anonimleşme hizmeti için bir arayüz ve uygulama oluşturun:

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

İnşaat API Kontrolörü

Dosya yüklemeyi ve anonim DICOM dosyalarını geri getiren bir denetleyici oluşturun:

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

Yapılandırılabilir profiller

Profillerin yapılandırılmasına izin verin appsettings.json:

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

Bir yapılandırma sınıfı oluşturun ve ayarlardan okumak için hizmeti güncelleyin:

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

Güvenlik Düşünceleri

Bu hizmeti kullanırken, bu güvenlik önlemlerini uygulayın.

**Trafikte tüm iletişimin şifrelenmesini sağlamak için HTTPS’i etkinleştirin. TLS 1.2 veya üstü ayarlayın ve Http’yi http’ye yönlendirin.

Uygulama kimlik doğrulaması JWT tokenleri veya API anahtarları kullanarak yetkili müşterilere erişimi kısıtlamak için:

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

Orijinal dosyaları diske şifrelenmemiş depolamaktan kaçının.Mümkün olduğunda ve geçici depolanmaya ihtiyaç duyulduğunda, gizlenmiş hacimleri kullanın.

Anonimleştirme işlemlerini izlemek için denetim girişini sağlar, bunları kimin talep ettiğini de dahil olmak üzere ve ne zaman:

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

• Performans optimizasyonu

Çeşitli teknikler yüksek performanslı senaryolar için performansı geliştirebilir.

Orijinal verileri hafızada saklamanız gerekmediğinde yerinde anonimleşme kullanın:

anonymizer.AnonymizeInPlace(dcm);

Batch işlemleri için paralel işleme sağlar:

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

RabbitMQ veya Azure Service Bus gibi bir mesaj çubuğu kullanarak çok büyük paketler için yükleme isteği uygulanır, hizmetleri aşırı derecede aşmaz.

Sonuçlar # sonuçlar

Şu anda ASP.NET Core’da bir DICOM anonimleşme mikroservisi oluşturmak için tam bir planınız var. Hizmet, HTTP aracılığıyla DIKOM dosyalarını kabul eder, Aspose.Medical’ı kullanarak yapılandırılabilir anonimizasyon profilleri uygular ve araştırma veya paylaşım için hazır olan tanımlanmamış dosyalar geri getirir.

Anahtar önlemler, bakım için katmanlı bir mimari kullanımı, esneklik için yapılandırılabilir profillerin uygulanması, servisin doğrulama ve şifreleme ile güvence altına alınması ve paralel işleme ile performans optimizasyonu içerir.

Tam kaynak kodu ve ek örnekler için lütfen Aspose.Tıbbi BelgelerAteşi denemek için, Ücretsiz geçici lisans alın.

More in this category