Azure Blob Storage와 C# 연동하기: 클라우드 저장소의 모든 것 🚀

클라우드 저장소의 세계로 함께 떠나는 신나는 여행!

안녕, 개발자 친구! 😊 오늘은 정말 흥미진진한 주제를 가지고 왔어. 바로 Azure Blob Storage와 C#의 환상적인 조합에 대해 함께 알아볼 거야. 클라우드 저장소가 어떻게 우리의 C# 애플리케이션과 춤을 출 수 있는지, 그 비밀을 하나하나 파헤쳐 볼게!

이 글은 2025년 2월 기준의 최신 정보를 담고 있어서, Azure의 최신 기능들과 C# 연동 방법을 모두 알 수 있을 거야. 마치 재능넷에서 전문가의 노하우를 배우듯, 나도 이 글을 통해 Azure Blob Storage의 모든 것을 너에게 전수해줄게! 자, 그럼 시작해볼까? 🎬

📚 목차

1. Azure Blob Storage란 무엇인가? 🤔
2. 개발 환경 설정하기 🛠️
3. Azure Storage 계정 만들기 ☁️
4. C#에서 Azure SDK 설치 및 기본 연결 설정 🔌
5. Blob 컨테이너 생성 및 관리하기 📦
6. 파일 업로드하기: 단일 파일부터 대용량 파일까지 📤
7. 파일 다운로드 및 읽기 📥
8. 고급 기능: 메타데이터, 속성, 리스 관리 🔍
9. 보안 및 SAS 토큰 다루기 🔒
10. 성능 최적화 팁 🚀
11. 실전 예제: 이미지 갤러리 만들기 🖼️
12. 문제 해결 및 디버깅 팁 🐞
13. 마무리 및 다음 단계 🎯

1. Azure Blob Storage란 무엇인가? 🤔

Azure Blob Storage는 Microsoft의 클라우드 저장소 솔루션이야. 'Blob'이라는 이름이 좀 이상하게 들릴 수도 있는데, 이건 Binary Large Object의 약자야. 쉽게 말하면, 텍스트든 이미지든 비디오든 어떤 형태의 데이터든 다 저장할 수 있는 대용량 저장소라고 생각하면 돼! 🗄️

Blob Storage는 세 가지 주요 구성 요소로 이루어져 있어:

1. Storage Account(스토리지 계정): 모든 Azure Storage 서비스의 최상위 컨테이너야. 너의 모든 데이터가 이 안에 저장돼.
2. Container(컨테이너): 폴더와 비슷한 개념으로, 관련 Blob들을 그룹화해. 파일 시스템의 디렉토리라고 생각하면 쉬워!
3. Blob(블롭): 실제 파일 데이터야. 텍스트, 이미지, 비디오 등 어떤 형식이든 가능해.

Azure Blob Storage가 특별한 이유가 뭘까? 🌟

1. 확장성: 몇 KB부터 몇 TB까지 어떤 크기의 데이터든 저장할 수 있어.
2. 가용성: 99.9% 이상의 가용성을 보장해주니까 데이터 접근에 문제가 거의 없지.
3. 보안성: 데이터 암호화, 액세스 제어 등 다양한 보안 기능을 제공해.
4. 비용 효율성: 사용한 만큼만 지불하는 구조라 경제적이야.
5. 전 세계 접근성: 전 세계 어디서든 빠르게 데이터에 접근할 수 있어.

이런 특징들 덕분에 Azure Blob Storage는 웹 애플리케이션의 이미지, 문서 저장소부터 백업, 아카이브, 빅데이터 분석까지 다양한 시나리오에서 활용되고 있어. 특히 C#과 함께라면 더욱 강력한 애플리케이션을 만들 수 있지! 마치 재능넷에서 다양한 재능이 모여 시너지를 내듯, Azure와 C#도 함께 놀라운 결과물을 만들어낼 수 있어. 😉

2. 개발 환경 설정하기 🛠️

자, 이제 본격적으로 Azure Blob Storage와 C#을 연동하기 위한 개발 환경을 구축해볼까? 걱정 마, 어렵지 않아! 🤗

필요한 도구들

1. Visual Studio: 2022 버전이 가장 좋지만, 2019나 2017도 괜찮아. Community 에디션은 무료라서 부담 없이 사용할 수 있어!
2. .NET SDK: 최신 버전인 .NET 8.0을 추천하지만, .NET 6.0(LTS) 이상이면 충분해.
3. Azure 계정: Microsoft Azure 계정이 필요해. 처음이라면 무료 체험 계정을 만들 수 있어!
4. Azure Storage Explorer: 선택사항이지만, 있으면 정말 편리해. Blob Storage를 시각적으로 관리할 수 있거든.

Visual Studio 설치하기

아직 Visual Studio가 없다면, Visual Studio 다운로드 페이지에서 Community 에디션을 무료로 다운받을 수 있어. 설치할 때 꼭 'ASP.NET 및 웹 개발'과 'Azure 개발' 워크로드를 선택해줘! 이 두 가지가 우리의 Azure Blob Storage와 C# 연동 여정에 필수적이거든. 🧩

.NET SDK 설치하기

.NET 다운로드 페이지에서 최신 SDK를 설치하면 돼. 2025년 2월 기준으로는 .NET 8이 최신 버전이야. 설치는 정말 간단해서, 다운로드 받은 설치 파일을 실행하고 화면의 지시를 따르기만 하면 돼!

Azure Storage Explorer 설치하기

Azure Storage Explorer는 Azure Storage 리소스를 쉽게 관리할 수 있는 GUI 도구야. Azure Storage Explorer 다운로드 페이지에서 받을 수 있어. 이 도구는 Blob, Queue, Table 등 모든 Azure Storage 서비스를 시각적으로 관리할 수 있게 해주니까, 개발 과정에서 정말 유용하게 사용할 수 있을 거야! 🔍

개발 환경 설정이 완료되면, 이제 우리는 Azure Blob Storage와 C#을 연동할 준비가 된 거야! 마치 요리사가 주방을 완벽하게 세팅한 것처럼, 우리도 코딩을 시작할 준비가 끝났어. 다음 단계로 넘어가볼까? 🚶‍♂️

3. Azure Storage 계정 만들기 ☁️

이제 Azure Portal에서 Storage 계정을 만들어볼 차례야! 이 과정은 마치 우리 집의 창고를 만드는 것과 같아. 모든 데이터가 저장될 공간을 마련하는 거지! 🏠

Azure Portal에 로그인하기

먼저 Azure Portal에 접속해서 Microsoft 계정으로 로그인해줘. 아직 계정이 없다면 무료로 만들 수 있어. Azure는 처음 가입할 때 $200 상당의 크레딧을 제공하고, 많은 서비스를 12개월 동안 무료로 사용할 수 있게 해줘. 이건 정말 좋은 기회지! 💰

Storage 계정 생성하기

1. Azure Portal에 로그인한 후, 왼쪽 상단의 '리소스 만들기' 버튼을 클릭해.
2. '스토리지 계정'을 검색하고 선택해.
3. '만들기' 버튼을 클릭해서 스토리지 계정 생성 과정을 시작해.
4. 기본 정보를 입력해야 해:
   1. 구독: 사용할 Azure 구독을 선택해.
   2. 리소스 그룹: 새 리소스 그룹을 만들거나 기존 그룹을 선택해.
   3. 스토리지 계정 이름: 전 세계적으로 고유한 이름을 입력해. 소문자와 숫자만 사용 가능해!
   4. 지역: 가장 가까운 데이터 센터를 선택해. 한국에 있다면 '한국 중부'나 '동아시아'가 좋은 선택이야.
   5. 성능: 일반적으로 'Standard'를 선택하면 돼. 'Premium'은 특별히 높은 성능이 필요할 때 사용해.
   6. 계정 종류: 'StorageV2(범용 v2)'를 선택하는 것이 좋아.
   7. 복제: 'LRS(로컬 중복 저장소)'가 가장 경제적이지만, 중요한 데이터라면 'GRS(지역 중복 저장소)'를 고려해봐.
5. '검토 + 만들기' 버튼을 클릭한 다음, 정보를 확인하고 '만들기' 버튼을 눌러 스토리지 계정을 생성해.

액세스 키 확인하기

스토리지 계정이 생성되면, 우리 C# 애플리케이션에서 이 계정에 접근하기 위한 연결 문자열(Connection String)이나 액세스 키가 필요해. 이건 마치 창고의 열쇠와 같은 거야! 🔑

1. 생성된 스토리지 계정으로 이동해.
2. 왼쪽 메뉴에서 '액세스 키'를 클릭해.
3. 여기서 '연결 문자열'을 복사해두면 돼. 이 문자열은 C# 코드에서 Azure Storage에 연결할 때 사용할 거야.

이제 우리는 Azure Storage 계정을 성공적으로 만들었어! 이 계정은 우리가 C# 애플리케이션에서 파일을 저장하고 관리할 수 있는 클라우드 공간이 될 거야. 마치 재능넷에서 다양한 재능을 저장하고 공유하는 공간을 마련한 것처럼, 우리도 데이터를 위한 공간을 마련했어! 다음 단계에서는 C# 코드에서 이 스토리지 계정에 연결하는 방법을 알아볼 거야. 계속 따라와줘! 🚶‍♀️

4. C#에서 Azure SDK 설치 및 기본 연결 설정 🔌

자, 이제 우리의 C# 프로젝트에서 Azure Blob Storage에 연결할 차례야! 이 과정은 마치 우리가 만든 창고와 우리 집 사이에 전용 통로를 만드는 것과 같아. 이 통로를 통해 데이터를 자유롭게 주고받을 수 있게 될 거야! 🌉

새 C# 프로젝트 만들기

먼저 Visual Studio에서 새 프로젝트를 만들어보자:

1. Visual Studio를 실행하고 '새 프로젝트 만들기'를 클릭해.
2. C# 콘솔 앱(.NET Core)을 선택해. 물론 다른 유형의 프로젝트(WPF, ASP.NET Core 등)도 가능해!
3. 프로젝트 이름을 'AzureBlobDemo'로 지정하고 위치를 선택한 다음 '만들기'를 클릭해.

Azure Storage SDK 설치하기

이제 NuGet 패키지 관리자를 통해 Azure Storage SDK를 설치해야 해:

1. 솔루션 탐색기에서 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 'NuGet 패키지 관리'를 선택해.
2. '찾아보기' 탭을 클릭하고 검색 상자에 'Azure.Storage.Blobs'를 입력해.
3. 검색 결과에서 'Azure.Storage.Blobs' 패키지를 선택하고 '설치' 버튼을 클릭해.
4. 라이선스 동의 창이 나타나면 '동의함'을 클릭해.

기본 연결 코드 작성하기

이제 Program.cs 파일을 열고 다음과 같이 코드를 작성해보자:

using System;
using System.IO;
using System.Threading.Tasks;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;

namespace AzureBlobDemo
{
    class Program
    {
        // 연결 문자열을 여기에 입력해. Azure Portal에서 복사한 값을 사용해.
        static string connectionString = "여기에_연결_문자열_입력";
        
        // 사용할 컨테이너 이름
        static string containerName = "mycontainer";
        
        static async Task Main(string[] args)
        {
            Console.WriteLine("Azure Blob Storage에 연결 중...");
            
            try
            {
                // BlobServiceClient 생성
                BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
                
                // 연결 테스트: 계정 정보 가져오기
                Azure.Response accountInfo = await blobServiceClient.GetAccountInfoAsync();
                
                Console.WriteLine($"성공적으로 연결되었습니다!");
                Console.WriteLine($"계정 종류: {accountInfo.Value.AccountKind}");
                Console.WriteLine($"SKU 이름: {accountInfo.Value.SkuName}");
                
                Console.WriteLine("\n연결이 성공적으로 테스트되었습니다!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"오류 발생: {ex.Message}");
            }
            
            Console.WriteLine("\n아무 키나 눌러 종료하세요...");
            Console.ReadKey();
        }
    }
}

위 코드에서 connectionString 변수에 Azure Portal에서 복사한 연결 문자열을 붙여넣어야 해. 이 코드는 Azure Blob Storage에 연결하고, 계정 정보를 가져와서 연결이 성공적으로 이루어졌는지 테스트해.

연결 문자열 보안 처리하기

코드에 직접 연결 문자열을 넣는 것은 보안상 좋지 않아! 실제 애플리케이션에서는 다음과 같은 방법을 사용하는 것이 좋아:

1. 환경 변수 사용: 연결 문자열을 환경 변수로 설정하고 코드에서 읽어오는 방법
2. 사용자 비밀(User Secrets) 사용: 개발 환경에서는 .NET의 사용자 비밀 기능을 활용
3. Azure Key Vault 사용: 프로덕션 환경에서는 Azure Key Vault에 보안 정보를 저장하고 관리

사용자 비밀을 사용하는 예제 코드를 보여줄게:

// 프로젝트에 Microsoft.Extensions.Configuration.UserSecrets 패키지 추가 필요
using Microsoft.Extensions.Configuration;

// 설정 로드
var configuration = new ConfigurationBuilder()
    .AddUserSecrets()
    .Build();

// 연결 문자열 가져오기
string connectionString = configuration["AzureStorage:ConnectionString"];

이렇게 하면 연결 문자열을 코드에 직접 넣지 않고도 안전하게 관리할 수 있어! 🔒

이제 우리는 C# 코드에서 Azure Blob Storage에 성공적으로 연결했어! 이 연결은 앞으로 우리가 파일을 업로드하고, 다운로드하고, 관리하는 모든 작업의 기반이 될 거야. 다음 단계에서는 Blob 컨테이너를 생성하고 관리하는 방법을 알아볼 거야. 계속 따라와줘! 🚀

5. Blob 컨테이너 생성 및 관리하기 📦

이제 우리는 Azure Blob Storage에 성공적으로 연결했어! 다음 단계는 파일을 저장할 컨테이너(Container)를 만드는 거야. 컨테이너는 파일 시스템의 폴더와 비슷한 개념이라고 생각하면 돼. 여러 Blob(파일)을 논리적으로 그룹화하는 역할을 해! 📂

컨테이너 생성하기

컨테이너를 생성하는 코드를 작성해보자:

static async Task CreateContainerAsync()
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // 컨테이너가 존재하는지 확인
    bool containerExists = await containerClient.ExistsAsync();
    
    if (!containerExists)
    {
        // 컨테이너 생성 (기본적으로 Private 액세스)
        await containerClient.CreateAsync();
        Console.WriteLine($"컨테이너 '{containerName}'가 생성되었습니다.");
        
        // 선택적으로 컨테이너를 공개(Blob) 액세스로 설정
        // await containerClient.SetAccessPolicyAsync(PublicAccessType.Blob);
        // Console.WriteLine($"컨테이너 '{containerName}'가 공개 액세스로 설정되었습니다.");
    }
    else
    {
        Console.WriteLine($"컨테이너 '{containerName}'가 이미 존재합니다.");
    }
}

이 코드는 다음과 같은 작업을 수행해:

1. BlobServiceClient를 생성해 Azure Storage 서비스에 연결해.
2. GetBlobContainerClient 메서드를 사용해 컨테이너 클라이언트를 가져와.
3. ExistsAsync 메서드로 컨테이너가 이미 존재하는지 확인해.
4. 컨테이너가 없으면 CreateAsync 메서드로 새 컨테이너를 생성해.
5. 선택적으로 SetAccessPolicyAsync 메서드를 사용해 컨테이너의 액세스 정책을 설정할 수 있어.

컨테이너 액세스 수준 이해하기

Azure Blob Storage 컨테이너에는 세 가지 액세스 수준이 있어:

1. Private (기본값): 컨테이너와 그 안의 Blob은 계정 소유자만 액세스할 수 있어.
2. Blob: 컨테이너 내의 Blob은 공개적으로 읽을 수 있지만, 컨테이너 메타데이터와 컨테이너 내 Blob 목록은 비공개야.
3. Container: 컨테이너와 그 안의 모든 Blob이 공개적으로 읽을 수 있어. 이 설정은 보안에 주의해야 해!

컨테이너의 액세스 수준을 설정하는 코드는 다음과 같아:

// 컨테이너를 Blob 액세스 수준으로 설정
await containerClient.SetAccessPolicyAsync(PublicAccessType.Blob);

// 컨테이너를 Container 액세스 수준으로 설정
await containerClient.SetAccessPolicyAsync(PublicAccessType.Container);

// 컨테이너를 Private 액세스 수준으로 설정
await containerClient.SetAccessPolicyAsync(PublicAccessType.None);

컨테이너 목록 가져오기

스토리지 계정에 있는 모든 컨테이너 목록을 가져오는 코드를 작성해보자:

static async Task ListContainersAsync()
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    Console.WriteLine("컨테이너 목록:");
    
    // 비동기적으로 컨테이너 목록 가져오기
    await foreach (var container in blobServiceClient.GetBlobContainersAsync())
    {
        Console.WriteLine($"- {container.Name} (생성 시간: {container.Properties.CreatedOn})");
    }
}

이 코드는 GetBlobContainersAsync 메서드를 사용해 스토리지 계정의 모든 컨테이너를 열거하고, 각 컨테이너의 이름과 생성 시간을 출력해.

컨테이너 삭제하기

더 이상 필요하지 않은 컨테이너를 삭제하는 코드도 작성해보자:

static async Task DeleteContainerAsync(string containerToDelete)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerToDelete);
    
    // 컨테이너가 존재하는지 확인
    bool containerExists = await containerClient.ExistsAsync();
    
    if (containerExists)
    {
        // 컨테이너 삭제
        await containerClient.DeleteAsync();
        Console.WriteLine($"컨테이너 '{containerToDelete}'가 삭제되었습니다.");
    }
    else
    {
        Console.WriteLine($"컨테이너 '{containerToDelete}'가 존재하지 않습니다.");
    }
}

컨테이너 메타데이터 관리하기

컨테이너에 메타데이터를 추가하고 읽는 방법도 알아보자:

static async Task ManageContainerMetadataAsync()
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // 컨테이너가 존재하는지 확인
    bool containerExists = await containerClient.ExistsAsync();
    
    if (containerExists)
    {
        // 메타데이터 설정
        IDictionary metadata = new Dictionary
        {
            { "category", "images" },
            { "department", "marketing" },
            { "created", DateTime.UtcNow.ToString("yyyy-MM-dd") }
        };
        
        // 컨테이너에 메타데이터 설정
        await containerClient.SetMetadataAsync(metadata);
        Console.WriteLine("컨테이너 메타데이터가 설정되었습니다.");
        
        // 메타데이터 읽기
        var properties = await containerClient.GetPropertiesAsync();
        
        Console.WriteLine("컨테이너 메타데이터:");
        foreach (var item in properties.Value.Metadata)
        {
            Console.WriteLine($"- {item.Key}: {item.Value}");
        }
    }
    else
    {
        Console.WriteLine($"컨테이너 '{containerName}'가 존재하지 않습니다.");
    }
}

이 코드는 컨테이너에 메타데이터를 설정하고 읽는 방법을 보여줘. 메타데이터는 키-값 쌍으로 저장되며, 컨테이너에 대한 추가 정보를 저장하는 데 유용해!

이제 우리는 Azure Blob Storage에서 컨테이너를 생성하고, 관리하고, 삭제하는 방법을 배웠어! 컨테이너는 우리의 Blob(파일)을 저장하는 논리적인 그룹이야. 다음 단계에서는 실제로 이 컨테이너에 파일을 업로드하는 방법을 알아볼 거야. 계속 따라와줘! 🚀

6. 파일 업로드하기: 단일 파일부터 대용량 파일까지 📤

자, 이제 우리는 컨테이너를 만들었으니 실제로 파일을 업로드할 차례야! 이건 마치 우리가 만든 창고에 물건을 넣는 것과 같아. 작은 물건부터 큰 물건까지, 다양한 방식으로 저장해보자! 📦

단일 파일 업로드하기

가장 기본적인 파일 업로드 방법부터 시작해볼게:

static async Task UploadFileAsync(string localFilePath, string blobName = null)
{
    // 파일이 존재하는지 확인
    if (!File.Exists(localFilePath))
    {
        Console.WriteLine($"오류: 파일 '{localFilePath}'를 찾을 수 없습니다.");
        return;
    }
    
    // blobName이 지정되지 않은 경우 파일 이름 사용
    if (string.IsNullOrEmpty(blobName))
    {
        blobName = Path.GetFileName(localFilePath);
    }
    
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    Console.WriteLine($"'{localFilePath}' 파일을 '{blobName}' Blob으로 업로드 중...");
    
    // 파일 업로드
    using (FileStream fileStream = File.OpenRead(localFilePath))
    {
        await blobClient.UploadAsync(fileStream, true);
    }
    
    Console.WriteLine($"파일이 성공적으로 업로드되었습니다!");
    Console.WriteLine($"Blob URL: {blobClient.Uri}");
}

이 코드는 로컬 파일 시스템에서 파일을 읽어 Azure Blob Storage에 업로드해. 주요 단계는 다음과 같아:

1. 파일이 존재하는지 확인해.
2. BlobServiceClient, BlobContainerClient, BlobClient 객체를 차례로 생성해.
3. FileStream을 사용해 파일을 읽고 UploadAsync 메서드로 업로드해.
4. 업로드된 Blob의 URL을 출력해.

메모리 스트림에서 업로드하기

파일뿐만 아니라 메모리에 있는 데이터도 직접 업로드할 수 있어:

static async Task UploadFromMemoryAsync(string blobName, string content)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    Console.WriteLine($"메모리에서 '{blobName}' Blob으로 데이터 업로드 중...");
    
    // 문자열을 바이트 배열로 변환
    byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(content);
    
    // 메모리 스트림 생성
    using (MemoryStream memoryStream = new MemoryStream(byteArray))
    {
        // 스트림에서 업로드
        await blobClient.UploadAsync(memoryStream, true);
    }
    
    Console.WriteLine($"데이터가 성공적으로 업로드되었습니다!");
    Console.WriteLine($"Blob URL: {blobClient.Uri}");
}

이 코드는 문자열 데이터를 바이트 배열로 변환한 다음 MemoryStream을 통해 Blob으로 업로드해. 이 방법은 파일 시스템을 거치지 않고 메모리에서 직접 데이터를 업로드할 때 유용해!

대용량 파일 업로드하기

대용량 파일(예: 비디오, 대형 데이터셋)을 업로드할 때는 블록 Blob을 사용하는 것이 좋아. 이 방법은 파일을 작은 블록으로 나누어 업로드하므로 네트워크 문제가 발생해도 중단된 지점부터 다시 시작할 수 있어:

static async Task UploadLargeFileAsync(string localFilePath, string blobName = null)
{
    // 파일이 존재하는지 확인
    if (!File.Exists(localFilePath))
    {
        Console.WriteLine($"오류: 파일 '{localFilePath}'를 찾을 수 없습니다.");
        return;
    }
    
    // blobName이 지정되지 않은 경우 파일 이름 사용
    if (string.IsNullOrEmpty(blobName))
    {
        blobName = Path.GetFileName(localFilePath);
    }
    
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    Console.WriteLine($"대용량 파일 '{localFilePath}'를 '{blobName}' Blob으로 업로드 중...");
    
    // 업로드 옵션 설정
    BlobUploadOptions options = new BlobUploadOptions
    {
        TransferOptions = new StorageTransferOptions
        {
            // 병렬 작업 수와 블록 크기 설정
            MaximumConcurrency = 8,
            MaximumTransferSize = 4 * 1024 * 1024 // 4MB
        }
    };
    
    // 파일 업로드
    using (FileStream fileStream = File.OpenRead(localFilePath))
    {
        // 진행 상황을 추적하기 위한 변수
        long fileSize = fileStream.Length;
        long uploadedBytes = 0;
        DateTime startTime = DateTime.Now;
        
        // 진행 상황 보고 콜백 함수
        Action progressHandler = (bytesTransferred) =>
        {
            uploadedBytes = bytesTransferred;
            double percentage = (double)uploadedBytes / fileSize * 100;
            TimeSpan elapsed = DateTime.Now - startTime;
            double speed = uploadedBytes / elapsed.TotalSeconds / (1024 * 1024); // MB/s
            
            Console.Write($"\r업로드 중: {percentage:F2}% 완료 ({FormatFileSize(uploadedBytes)}/{FormatFileSize(fileSize)}) - {speed:F2} MB/s");
        };
        
        // 업로드 (진행 상황 보고 포함)
        await blobClient.UploadAsync(fileStream, options);
        
        Console.WriteLine("\n파일이 성공적으로 업로드되었습니다!");
        Console.WriteLine($"Blob URL: {blobClient.Uri}");
        
        TimeSpan totalTime = DateTime.Now - startTime;
        Console.WriteLine($"총 업로드 시간: {totalTime.TotalSeconds:F2}초");
    }
}

// 파일 크기를 읽기 쉬운 형식으로 변환하는 도우미 함수
static string FormatFileSize(long bytes)
{
    string[] suffixes = { "B", "KB", "MB", "GB", "TB" };
    int counter = 0;
    double size = bytes;
    
    while (size > 1024 && counter < suffixes.Length - 1)
    {
        size /= 1024;
        counter++;
    }
    
    return $"{size:F2} {suffixes[counter]}";
}

이 코드는 대용량 파일을 효율적으로 업로드하기 위한 여러 기능을 포함하고 있어:

1. 병렬 업로드: MaximumConcurrency 옵션으로 여러 블록을 동시에 업로드해.
2. 블록 크기 설정: MaximumTransferSize 옵션으로 각 블록의 크기를 설정해.
3. 진행 상황 보고: 업로드 진행 상황을 실시간으로 보여줘.
4. 속도 계산: 업로드 속도를 MB/s 단위로 계산해 보여줘.

Blob 속성 및 메타데이터 설정하기

파일을 업로드할 때 추가 정보를 함께 저장하고 싶다면 Blob 속성과 메타데이터를 설정할 수 있어:

static async Task UploadWithMetadataAsync(string localFilePath, string blobName = null)
{
    // 파일이 존재하는지 확인
    if (!File.Exists(localFilePath))
    {
        Console.WriteLine($"오류: 파일 '{localFilePath}'를 찾을 수 없습니다.");
        return;
    }
    
    // blobName이 지정되지 않은 경우 파일 이름 사용
    if (string.IsNullOrEmpty(blobName))
    {
        blobName = Path.GetFileName(localFilePath);
    }
    
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    Console.WriteLine($"'{localFilePath}' 파일을 메타데이터와 함께 업로드 중...");
    
    // 메타데이터 설정
    IDictionary metadata = new Dictionary
    {
        { "createdby", "csharp-app" },
        { "department", "engineering" },
        { "category", Path.GetExtension(localFilePath).TrimStart('.') },
        { "uploaddate", DateTime.UtcNow.ToString("yyyy-MM-dd") }
    };
    
    // HTTP 헤더 설정
    BlobHttpHeaders headers = new BlobHttpHeaders
    {
        // 콘텐츠 타입 설정 (파일 확장자에 따라)
        ContentType = GetContentType(localFilePath),
        // 캐싱 설정
        CacheControl = "public, max-age=86400" // 1일 동안 캐싱
    };
    
    // 업로드 옵션 설정
    BlobUploadOptions options = new BlobUploadOptions
    {
        Metadata = metadata,
        HttpHeaders = headers
    };
    
    // 파일 업로드
    using (FileStream fileStream = File.OpenRead(localFilePath))
    {
        await blobClient.UploadAsync(fileStream, options);
    }
    
    Console.WriteLine($"파일이 메타데이터와 함께 성공적으로 업로드되었습니다!");
    Console.WriteLine($"Blob URL: {blobClient.Uri}");
}

// 파일 확장자에 따라 콘텐츠 타입을 반환하는 도우미 함수
static string GetContentType(string filePath)
{
    string extension = Path.GetExtension(filePath).ToLowerInvariant();
    
    return extension switch
    {
        ".txt" => "text/plain",
        ".html" => "text/html",
        ".htm" => "text/html",
        ".json" => "application/json",
        ".jpg" => "image/jpeg",
        ".jpeg" => "image/jpeg",
        ".png" => "image/png",
        ".gif" => "image/gif",
        ".pdf" => "application/pdf",
        ".doc" => "application/msword",
        ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
        ".xls" => "application/vnd.ms-excel",
        ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        ".zip" => "application/zip",
        ".mp3" => "audio/mpeg",
        ".mp4" => "video/mp4",
        _ => "application/octet-stream" // 기본값
    };
}

이 코드는 파일을 업로드할 때 다음과 같은 추가 정보를 설정해:

1. 메타데이터: 파일에 대한 추가 정보를 키-값 쌍으로 저장해.
2. HTTP 헤더: ContentType을 설정해 브라우저가 파일을 올바르게 해석할 수 있게 하고, CacheControl을 설정해 캐싱 동작을 제어해.

이제 우리는 Azure Blob Storage에 파일을 업로드하는 다양한 방법을 배웠어! 단일 파일부터 대용량 파일까지, 메타데이터와 HTTP 헤더까지 설정할 수 있게 되었지. 다음 단계에서는 이렇게 업로드한 파일을 다운로드하고 읽는 방법을 알아볼 거야. 계속 따라와줘! 🚀

7. 파일 다운로드 및 읽기 📥

이제 우리는 Azure Blob Storage에 파일을 업로드하는 방법을 배웠어. 다음은 이 파일들을 다운로드하고 읽는 방법을 알아볼 차례야! 이건 마치 우리가 창고에 넣어둔 물건을 다시 꺼내오는 것과 같아. 다양한 방법으로 파일을 가져와보자! 🧳

단일 파일 다운로드하기

가장 기본적인 파일 다운로드 방법부터 시작해볼게:

static async Task DownloadFileAsync(string blobName, string localFilePath = null)
{
    // 로컬 파일 경로가 지정되지 않은 경우 현재 디렉토리에 같은 이름으로 저장
    if (string.IsNullOrEmpty(localFilePath))
    {
        localFilePath = blobName;
    }
    
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    Console.WriteLine($"'{blobName}' Blob을 '{localFilePath}'로 다운로드 중...");
    
    // 파일 다운로드
    BlobDownloadInfo download = await blobClient.DownloadAsync();
    
    // 로컬 파일로 저장
    using (FileStream fileStream = File.OpenWrite(localFilePath))
    {
        await download.Content.CopyToAsync(fileStream);
    }
    
    Console.WriteLine($"파일이 성공적으로 다운로드되었습니다!");
}

이 코드는 Azure Blob Storage에서 파일을 다운로드해 로컬 파일 시스템에 저장해. 주요 단계는 다음과 같아:

1. BlobServiceClient, BlobContainerClient, BlobClient 객체를 차례로 생성해.
2. Blob이 존재하는지 확인해.
3. DownloadAsync 메서드로 Blob의 내용을 다운로드해.
4. 다운로드한 내용을 FileStream을 사용해 로컬 파일로 저장해.

메모리로 직접 다운로드하기

파일을 로컬 디스크에 저장하지 않고 메모리에서 직접 처리하고 싶을 때는 다음과 같은 방법을 사용할 수 있어:

static async Task DownloadToMemoryAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    Console.WriteLine($"'{blobName}' Blob을 메모리로 다운로드 중...");
    
    // Blob 다운로드
    BlobDownloadInfo download = await blobClient.DownloadAsync();
    
    // 메모리 스트림으로 복사
    using (MemoryStream memoryStream = new MemoryStream())
    {
        await download.Content.CopyToAsync(memoryStream);
        memoryStream.Position = 0; // 스트림 위치를 처음으로 되돌림
        
        // 텍스트 파일인 경우 내용 출력 (예시)
        if (download.ContentType.Contains("text") || Path.GetExtension(blobName).ToLower() == ".txt")
        {
            using (StreamReader reader = new StreamReader(memoryStream))
            {
                string content = await reader.ReadToEndAsync();
                Console.WriteLine("파일 내용 (처음 500자):");
                Console.WriteLine(content.Length > 500 ? content.Substring(0, 500) + "..." : content);
            }
        }
        else
        {
            Console.WriteLine($"파일이 메모리로 다운로드되었습니다. 크기: {memoryStream.Length} 바이트");
        }
    }
}

이 코드는 Blob의 내용을 메모리로 다운로드하고, 텍스트 파일인 경우 내용을 출력해. 이 방법은 파일을 임시로 처리하거나, 내용을 분석하거나, 변환할 때 유용해!

대용량 파일 다운로드하기

대용량 파일을 다운로드할 때는 진행 상황을 추적하고 효율적으로 처리하는 것이 중요해:

static async Task DownloadLargeFileAsync(string blobName, string localFilePath = null)
{
    // 로컬 파일 경로가 지정되지 않은 경우 현재 디렉토리에 같은 이름으로 저장
    if (string.IsNullOrEmpty(localFilePath))
    {
        localFilePath = blobName;
    }
    
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    // Blob 속성 가져오기
    BlobProperties properties = await blobClient.GetPropertiesAsync();
    long blobSize = properties.ContentLength;
    
    Console.WriteLine($"대용량 파일 '{blobName}'을 '{localFilePath}'로 다운로드 중...");
    Console.WriteLine($"파일 크기: {FormatFileSize(blobSize)}");
    
    // 다운로드 옵션 설정
    BlobDownloadOptions options = new BlobDownloadOptions
    {
        TransferOptions = new StorageTransferOptions
        {
            // 병렬 작업 수와 블록 크기 설정
            MaximumConcurrency = 8,
            MaximumTransferSize = 4 * 1024 * 1024 // 4MB
        }
    };
    
    // 파일 다운로드
    DateTime startTime = DateTime.Now;
    
    // 파일 스트림 생성
    using (FileStream fileStream = File.OpenWrite(localFilePath))
    {
        // 진행 상황을 주기적으로 보고하기 위한 타이머
        System.Timers.Timer progressTimer = new System.Timers.Timer(500); // 500ms마다 업데이트
        progressTimer.Elapsed += (sender, e) =>
        {
            if (fileStream.Length > 0)
            {
                double percentage = (double)fileStream.Length / blobSize * 100;
                TimeSpan elapsed = DateTime.Now - startTime;
                double speed = fileStream.Length / elapsed.TotalSeconds / (1024 * 1024); // MB/s
                
                Console.Write($"\r다운로드 중: {percentage:F2}% 완료 ({FormatFileSize(fileStream.Length)}/{FormatFileSize(blobSize)}) - {speed:F2} MB/s");
            }
        };
        progressTimer.Start();
        
        // 다운로드 실행
        await blobClient.DownloadToAsync(fileStream);
        
        // 타이머 중지
        progressTimer.Stop();
        progressTimer.Dispose();
    }
    
    TimeSpan totalTime = DateTime.Now - startTime;
    Console.WriteLine($"\n파일이 성공적으로 다운로드되었습니다!");
    Console.WriteLine($"총 다운로드 시간: {totalTime.TotalSeconds:F2}초");
}

// 파일 크기를 읽기 쉬운 형식으로 변환하는 도우미 함수 (이전에 정의한 것과 동일)
static string FormatFileSize(long bytes)
{
    string[] suffixes = { "B", "KB", "MB", "GB", "TB" };
    int counter = 0;
    double size = bytes;
    
    while (size > 1024 && counter < suffixes.Length - 1)
    {
        size /= 1024;
        counter++;
    }
    
    return $"{size:F2} {suffixes[counter]}";
}

이 코드는 대용량 파일을 효율적으로 다운로드하기 위한 여러 기능을 포함하고 있어:

1. 병렬 다운로드: MaximumConcurrency 옵션으로 여러 블록을 동시에 다운로드해.
2. 블록 크기 설정: MaximumTransferSize 옵션으로 각 블록의 크기를 설정해.
3. 진행 상황 보고: 타이머를 사용해 다운로드 진행 상황을 실시간으로 보여줘.
4. 속도 계산: 다운로드 속도를 MB/s 단위로 계산해 보여줘.

Blob 메타데이터 및 속성 읽기

파일을 다운로드하기 전에 메타데이터나 속성을 확인하고 싶을 때는 다음과 같은 방법을 사용할 수 있어:

static async Task ReadBlobMetadataAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    Console.WriteLine($"'{blobName}' Blob의 메타데이터와 속성 읽는 중...");
    
    // Blob 속성 가져오기
    BlobProperties properties = await blobClient.GetPropertiesAsync();
    
    // 기본 속성 출력
    Console.WriteLine("\n기본 속성:");
    Console.WriteLine($"- 콘텐츠 타입: {properties.ContentType}");
    Console.WriteLine($"- 콘텐츠 길이: {FormatFileSize(properties.ContentLength)}");
    Console.WriteLine($"- 생성 시간: {properties.CreatedOn}");
    Console.WriteLine($"- 마지막 수정 시간: {properties.LastModified}");
    Console.WriteLine($"- Blob 타입: {properties.BlobType}");
    
    // 메타데이터 출력
    Console.WriteLine("\n메타데이터:");
    if (properties.Metadata.Count > 0)
    {
        foreach (var item in properties.Metadata)
        {
            Console.WriteLine($"- {item.Key}: {item.Value}");
        }
    }
    else
    {
        Console.WriteLine("메타데이터가 없습니다.");
    }
}

이 코드는 Blob의 속성과 메타데이터를 가져와 출력해. 이 정보는 파일을 다운로드하기 전에 파일의 특성을 파악하거나, 메타데이터를 기반으로 특정 작업을 수행할 때 유용해!

스트리밍 방식으로 Blob 읽기

대용량 파일을 전체 다운로드하지 않고 스트리밍 방식으로 읽고 싶을 때는 다음과 같은 방법을 사용할 수 있어:

static async Task StreamBlobContentAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    Console.WriteLine($"'{blobName}' Blob을 스트리밍 방식으로 읽는 중...");
    
    // Blob 다운로드
    BlobDownloadInfo download = await blobClient.DownloadAsync();
    
    // 텍스트 파일인 경우 스트리밍 방식으로 내용 읽기
    if (download.ContentType.Contains("text") || Path.GetExtension(blobName).ToLower() == ".txt")
    {
        using (StreamReader reader = new StreamReader(download.Content))
        {
            int lineCount = 0;
            string line;
            
            Console.WriteLine("\n파일 내용 (처음 10줄):");
            
            while ((line = await reader.ReadLineAsync()) != null && lineCount < 10)
            {
                Console.WriteLine($"{++lineCount}: {line}");
            }
            
            if (await reader.ReadLineAsync() != null)
            {
                Console.WriteLine("...(더 많은 내용이 있습니다)");
            }
        }
    }
    else
    {
        Console.WriteLine($"이 파일은 텍스트 형식이 아니므로 내용을 표시할 수 없습니다.");
        Console.WriteLine($"콘텐츠 타입: {download.ContentType}");
    }
}

이 코드는 Blob의 내용을 스트리밍 방식으로 읽어 처리해. 이 방법은 전체 파일을 메모리에 로드하지 않고 한 번에 일부분만 처리하므로, 대용량 파일을 효율적으로 처리할 수 있어!

이제 우리는 Azure Blob Storage에서 파일을 다운로드하고 읽는 다양한 방법을 배웠어! 단일 파일부터 대용량 파일까지, 메모리로 직접 다운로드하거나 스트리밍 방식으로 읽는 방법까지 알게 되었지. 다음 단계에서는 Blob의 고급 기능들을 알아볼 거야. 계속 따라와줘! 🚀

8. 고급 기능: 메타데이터, 속성, 리스 관리 🔍

자, 이제 우리는 Azure Blob Storage의 기본적인 파일 업로드와 다운로드 방법을 배웠어. 이제는 한 단계 더 나아가서 고급 기능들을 알아볼 차례야! 이런 기능들은 마치 창고 관리 시스템을 더 효율적으로 만드는 것과 같아. 더 스마트하게 파일을 관리해보자! 🧠

Blob 메타데이터 관리하기

메타데이터는 Blob에 대한 추가 정보를 저장하는 키-값 쌍이야. 이를 통해 파일을 더 쉽게 분류하고 검색할 수 있지:

static async Task ManageBlobMetadataAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    // 현재 메타데이터 가져오기
    BlobProperties properties = await blobClient.GetPropertiesAsync();
    
    Console.WriteLine($"'{blobName}' Blob의 현재 메타데이터:");
    if (properties.Metadata.Count > 0)
    {
        foreach (var item in properties.Metadata)
        {
            Console.WriteLine($"- {item.Key}: {item.Value}");
        }
    }
    else
    {
        Console.WriteLine("메타데이터가 없습니다.");
    }
    
    // 새 메타데이터 설정
    IDictionary metadata = new Dictionary
    {
        { "author", "csharp-developer" },
        { "version", "1.0.2" },
        { "lastreviewed", DateTime.UtcNow.ToString("yyyy-MM-dd") },
        { "status", "active" }
    };
    
    // 기존 메타데이터가 있으면 일부 유지
    if (properties.Metadata.ContainsKey("createdby"))
    {
        metadata["createdby"] = properties.Metadata["createdby"];
    }
    
    // 메타데이터 설정
    await blobClient.SetMetadataAsync(metadata);
    
    Console.WriteLine("\n새 메타데이터가 설정되었습니다!");
    
    // 업데이트된 메타데이터 확인
    properties = await blobClient.GetPropertiesAsync();
    
    Console.WriteLine("\n업데이트된 메타데이터:");
    foreach (var item in properties.Metadata)
    {
        Console.WriteLine($"- {item.Key}: {item.Value}");
    }
}

이 코드는 Blob의 메타데이터를 가져오고, 새 메타데이터를 설정하는 방법을 보여줘. 메타데이터는 파일 자체의 내용을 변경하지 않고 추가 정보를 저장할 수 있는 좋은 방법이야!

Blob 속성 관리하기

Blob 속성은 콘텐츠 타입, 캐시 제어 설정 등 Blob의 동작을 제어하는 데 사용돼:

static async Task ManageBlobPropertiesAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    // 현재 속성 가져오기
    BlobProperties properties = await blobClient.GetPropertiesAsync();
    
    Console.WriteLine($"'{blobName}' Blob의 현재 속성:");
    Console.WriteLine($"- 콘텐츠 타입: {properties.ContentType}");
    Console.WriteLine($"- 콘텐츠 인코딩: {properties.ContentEncoding}");
    Console.WriteLine($"- 콘텐츠 언어: {properties.ContentLanguage}");
    Console.WriteLine($"- 캐시 제어: {properties.CacheControl}");
    Console.WriteLine($"- 콘텐츠 MD5: {(properties.ContentHash != null ? Convert.ToBase64String(properties.ContentHash) : "없음")}");
    
    // 새 속성 설정
    BlobHttpHeaders headers = new BlobHttpHeaders
    {
        ContentType = "application/pdf", // 예: PDF 파일로 설정
        ContentLanguage = "ko-KR",
        ContentEncoding = "identity",
        CacheControl = "public, max-age=3600", // 1시간 캐싱
        ContentDisposition = $"attachment; filename=\"{blobName}\"" // 다운로드 시 파일 이름 지정
    };
    
    // 속성 설정
    await blobClient.SetHttpHeadersAsync(headers);
    
    Console.WriteLine("\n새 속성이 설정되었습니다!");
    
    // 업데이트된 속성 확인
    properties = await blobClient.GetPropertiesAsync();
    
    Console.WriteLine("\n업데이트된 속성:");
    Console.WriteLine($"- 콘텐츠 타입: {properties.ContentType}");
    Console.WriteLine($"- 콘텐츠 인코딩: {properties.ContentEncoding}");
    Console.WriteLine($"- 콘텐츠 언어: {properties.ContentLanguage}");
    Console.WriteLine($"- 캐시 제어: {properties.CacheControl}");
    Console.WriteLine($"- 콘텐츠 배치: {properties.ContentDisposition}");
}

이 코드는 Blob의 HTTP 헤더를 관리하는 방법을 보여줘. 이런 속성들은 브라우저가 Blob을 어떻게 처리할지 결정하는 데 중요한 역할을 해!

Blob 리스(Lease) 관리하기

리스는 Blob에 대한 독점적인 쓰기 액세스 권한을 제공해. 이를 통해 여러 클라이언트가 동시에 같은 Blob을 수정하는 것을 방지할 수 있어:

static async Task ManageBlobLeaseAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    // 특수 클라이언트 가져오기
    BlobLeaseClient leaseClient = blobClient.GetBlobLeaseClient();
    
    try
    {
        Console.WriteLine($"'{blobName}' Blob에 대한 리스 획득 중...");
        
        // 15초 동안 리스 획득
        Azure.Response leaseResponse = await leaseClient.AcquireAsync(TimeSpan.FromSeconds(15));
        string leaseId = leaseResponse.Value.LeaseId;
        
        Console.WriteLine($"리스가 성공적으로 획득되었습니다! 리스 ID: {leaseId}");
        Console.WriteLine("이제 15초 동안 이 Blob에 대한 독점적인 액세스 권한이 있습니다.");
        
        // 리스를 사용한 작업 예시: 메타데이터 업데이트
        IDictionary metadata = new Dictionary
        {
            { "leasemodified", DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") }
        };
        
        // 리스 ID를 사용하여 메타데이터 설정
        await blobClient.SetMetadataAsync(metadata, new BlobRequestConditions { LeaseId = leaseId });
        
        Console.WriteLine("리스를 사용하여 메타데이터가 업데이트되었습니다.");
        
        // 리스 갱신 (필요한 경우)
        await leaseClient.RenewAsync();
        Console.WriteLine("리스가 갱신되었습니다.");
        
        // 리스 해제
        await leaseClient.ReleaseAsync();
        Console.WriteLine("리스가 해제되었습니다.");
    }
    catch (RequestFailedException ex) when (ex.ErrorCode == "LeaseAlreadyPresent")
    {
        Console.WriteLine("오류: 이 Blob에는 이미 활성 리스가 있습니다.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"오류 발생: {ex.Message}");
    }
}

이 코드는 Blob에 대한 리스를 획득하고, 갱신하고, 해제하는 방법을 보여줘. 리스는 다음과 같은 상황에서 유용해:

1. 동시 수정 방지: 여러 클라이언트가 동시에 같은 Blob을 수정하는 것을 방지해.
2. 원자적 업데이트: 여러 작업을 원자적으로 수행할 수 있게 해.
3. 삭제 방지: 리스가 있는 동안 Blob이 삭제되는 것을 방지해.

Blob 스냅샷 관리하기

스냅샷은 특정 시점의 Blob 상태를 저장하는 읽기 전용 버전이야. 이를 통해 Blob의 이전 버전을 보존하고 필요할 때 복원할 수 있어:

static async Task ManageBlobSnapshotsAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    try
    {
        Console.WriteLine($"'{blobName}' Blob의 스냅샷 생성 중...");
        
        // 스냅샷 생성
        BlobSnapshotInfo snapshotInfo = await blobClient.CreateSnapshotAsync();
        string snapshotTime = snapshotInfo.Snapshot.ToString();
        
        Console.WriteLine($"스냅샷이 성공적으로 생성되었습니다! 스냅샷 시간: {snapshotTime}");
        
        // 스냅샷 목록 가져오기
        Console.WriteLine("\n스냅샷 목록:");
        
        // 이 Blob의 모든 스냅샷 나열
        await foreach (BlobItem blobItem in containerClient.GetBlobsAsync(
            prefix: blobName,
            traits: BlobTraits.Snapshots))
        {
            if (blobItem.Snapshot != null)
            {
                Console.WriteLine($"- 스냅샷 시간: {blobItem.Snapshot}, 크기: {FormatFileSize(blobItem.Properties.ContentLength ?? 0)}");
            }
        }
        
        // 스냅샷에서 읽기
        BlobClient snapshotClient = containerClient.GetBlobClient(blobName).WithSnapshot(snapshotInfo.Snapshot);
        
        // 스냅샷이 텍스트 파일인 경우 내용 읽기
        BlobProperties properties = await snapshotClient.GetPropertiesAsync();
        
        if (properties.ContentType.Contains("text") || Path.GetExtension(blobName).ToLower() == ".txt")
        {
            BlobDownloadInfo download = await snapshotClient.DownloadAsync();
            
            using (StreamReader reader = new StreamReader(download.Content))
            {
                string content = await reader.ReadToEndAsync();
                Console.WriteLine("\n스냅샷 내용 (처음 100자):");
                Console.WriteLine(content.Length > 100 ? content.Substring(0, 100) + "..." : content);
            }
        }
        
        // 스냅샷 삭제 (선택 사항)
        // await snapshotClient.DeleteAsync();
        // Console.WriteLine($"스냅샷이 삭제되었습니다.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"오류 발생: {ex.Message}");
    }
}

이 코드는 Blob의 스냅샷을 생성하고, 목록을 가져오고, 스냅샷에서 데이터를 읽는 방법을 보여줘. 스냅샷은 다음과 같은 상황에서 유용해:

1. 백업 및 복원: Blob의 이전 상태를 보존하고 필요할 때 복원할 수 있어.
2. 버전 관리: 파일의 여러 버전을 관리할 수 있어.
3. 데이터 보호: 실수로 인한 데이터 손실을 방지할 수 있어.

Blob 태그 관리하기

Azure Blob Storage는 메타데이터 외에도 태그를 지원해. 태그는 인덱싱되므로 태그 기반 쿼리를 사용해 Blob을 빠르게 찾을 수 있어:

static async Task ManageBlobTagsAsync(string blobName)
{
    // BlobServiceClient 생성
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    try
    {
        // 현재 태그 가져오기
        IDictionary tags = await blobClient.GetTagsAsync();
        
        Console.WriteLine($"'{blobName}' Blob의 현재 태그:");
        if (tags.Count > 0)
        {
            foreach (var tag in tags)
            {
                Console.WriteLine($"- {tag.Key}: {tag.Value}");
            }
        }
        else
        {
            Console.WriteLine("태그가 없습니다.");
        }
        
        // 새 태그 설정
        IDictionary newTags = new Dictionary
        {
            { "project", "azure-demo" },
            { "environment", "development" },
            { "department", "engineering" },
            { "priority", "high" }
        };
        
        // 태그 설정
        await blobClient.SetTagsAsync(newTags);
        
        Console.WriteLine("\n새 태그가 설정되었습니다!");
        
        // 업데이트된 태그 확인
        tags = await blobClient.GetTagsAsync();
        
        Console.WriteLine("\n업데이트된 태그:");
        foreach (var tag in tags)
        {
            Console.WriteLine($"- {tag.Key}: {tag.Value}");
        }
        
        // 태그 기반 쿼리 예시 (컨테이너 내에서)
        string query = "@container = '" + containerName + "' AND \"project\" = 'azure-demo' AND \"priority\" = 'high'";
        
        Console.WriteLine("\n태그 기반 쿼리 실행 중:");
        Console.WriteLine($"쿼리: {query}");
        
        int count = 0;
        await foreach (TaggedBlobItem item in blobServiceClient.FindBlobsByTagsAsync(query))
        {
            count++;
            Console.WriteLine($"- {item.BlobName} (컨테이너: {item.BlobContainerName})");
        }
        
        Console.WriteLine($"\n총 {count}개의 Blob이 쿼리와 일치합니다.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"오류 발생: {ex.Message}");
    }
}

이 코드는 Blob의 태그를 설정하고, 가져오고, 태그 기반 쿼리를 실행하는 방법을 보여줘. 태그는 다음과 같은 장점이 있어:

1. 인덱싱: 태그는 인덱싱되므로 빠른 검색이 가능해.
2. SQL 유사 쿼리: SQL과 유사한 구문으로 태그 기반 쿼리를 작성할 수 있어.
3. 메타데이터와 별도 관리: 태그는 메타데이터와 별도로 관리되므로 더 유연한 데이터 관리가 가능해.

이제 우리는 Azure Blob Storage의 고급 기능들을 배웠어! 메타데이터, 속성, 리스, 스냅샷, 태그 등을 활용하면 더 효율적이고 강력한 클라우드 저장소 솔루션을 구축할 수 있어. 이런 기능들은 마치 재능넷에서 다양한 재능을 체계적으로 관리하는 것과 같아. 다음 단계에서는 보안 및 SAS 토큰에 대해 알아볼 거야. 계속 따라와줘! 🚀

9. 보안 및 SAS 토큰 다루기 🔒

자, 이제 우리는 Azure Blob Storage의 다양한 기능들을 배웠어. 하지만 클라우드 저장소를 사용할 때 가장 중요한 것 중 하나는 바로 보안이야! 이건 마치 우리 창고에 튼튼한 자물쇠를 달고, 필요한 사람에게만 열쇠를 주는 것과 같아. 안전하게 데이터를 보호하면서도 필요한 접근을 허용하는 방법을 알아보자! 🔐

SAS(Shared Access Signature) 토큰이란?

SAS 토큰은 Azure Storage 리소스에 대한 제한된 액세스 권한을 부여하는 URL 쿼리 매개변수야. 이를 통해 스토리지 계정 키를 공유하지 않고도 특정 리소스에 대한 특정 권한을 부여할 수 있어!

SAS 토큰의 주요 특징은 다음과 같아:

1. 시간 제한: 특정 기간 동안만 유효하도록 설정할 수 있어.
2. 권한 제한: 읽기, 쓰기, 삭제 등 특정 작업만 허용할 수 있어.
3. IP 제한: 특정 IP 주소나 범위에서만 액세스할 수 있도록 제한할 수 있어.
4. 프로토콜 제한: HTTPS만 사용하도록 강제할 수 있어.

Blob에 대한 SAS 토큰 생성하기

특정 Blob에 대한 SAS 토큰을 생성하는 코드를 작성해보자:

static async Task CreateBlobSasTokenAsync(string blobName)
{
    // BlobServiceClient 생성 (연결 문자열에서 계정 키 필요)
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // Blob이 존재하는지 확인
    bool blobExists = await blobClient.ExistsAsync();
    
    if (!blobExists)
    {
        Console.WriteLine($"오류: Blob '{blobName}'을 찾을 수 없습니다.");
        return;
    }
    
    // 연결 문자열에서 계정 이름과 키 추출
    string[] parts = connectionString.Split(';');
    string accountName = "";
    string accountKey = "";
    
    foreach (string part in parts)
    {
        if (part.StartsWith("AccountName="))
        {
            accountName = part.Substring("AccountName=".Length);
        }
        else if (part.StartsWith("AccountKey="))
        {
            accountKey = part.Substring("AccountKey=".Length);
        }
    }
    
    if (string.IsNullOrEmpty(accountName) || string.IsNullOrEmpty(accountKey))
    {
        Console.WriteLine("오류: 연결 문자열에서 계정 이름 또는 키를 추출할 수 없습니다.");
        return;
    }
    
    // 공유 키 자격 증명 생성
    StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);
    
    // SAS 토큰이 유효한 시간 설정
    DateTimeOffset expiresOn = DateTimeOffset.UtcNow.AddHours(1); // 1시간 후 만료
    
    // 읽기 전용 SAS 토큰 생성
    BlobSasBuilder sasBuilder = new BlobSasBuilder
    {
        BlobContainerName = containerName,
        BlobName = blobName,
        Resource = "b", // "b"는 Blob을 의미
        StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5), // 5분 전부터 유효 (시계 오차 허용)
        ExpiresOn = expiresOn
    };
    
    // 권한 설정 (읽기만 허용)
    sasBuilder.SetPermissions(BlobSasPermissions.Read);
    
    // SAS 토큰 생성
    string sasToken = sasBuilder.ToSasQueryParameters(credential).ToString();
    
    // SAS URL 생성
    string sasUrl = blobClient.Uri + "?" + sasToken;
    
    Console.WriteLine($"'{blobName}' Blob에 대한 읽기 전용 SAS 토큰이 생성되었습니다!");
    Console.WriteLine($"만료 시간: {expiresOn}");
    Console.WriteLine($"\nSAS URL: {sasUrl}");
    Console.WriteLine("\n이 URL을 사용하여 Blob에 직접 액세스할 수 있습니다.");
    Console.WriteLine("브라우저에서 열거나 다른 애플리케이션에서 사용해보세요!");
}

이 코드는 특정 Blob에 대한 읽기 전용 SAS 토큰을 생성해. 이 토큰은 1시간 동안 유효하며, 토큰이 포함된 URL을 통해 Blob에 직접 액세스할 수 있어!

컨테이너에 대한 SAS 토큰 생성하기

특정 컨테이너에 대한 SAS 토큰을 생성하는 코드도 작성해보자:

static async Task CreateContainerSasTokenAsync()
{
    // BlobServiceClient 생성 (연결 문자열에서 계정 키 필요)
    BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // 컨테이너가 존재하는지 확인
    bool containerExists = await containerClient.ExistsAsync();
    
    if (!containerExists)
    {
        Console.WriteLine($"오류: 컨테이너 '{containerName}'을 찾을 수 없습니다.");
        return;
    }
    
    // 연결 문자열에서 계정 이름과 키 추출
    string[] parts = connectionString.Split(';');
    string accountName = "";
    string accountKey = "";
    
    foreach (string part in parts)
    {
        if (part.StartsWith("AccountName="))
        {
            accountName = part.Substring("AccountName=".Length);
        }
        else if (part.StartsWith("AccountKey="))
        {
            accountKey = part.Substring("AccountKey=".Length);
        }
    }
    
    if (string.IsNullOrEmpty(accountName) || string.IsNullOrEmpty(accountKey))
    {
        Console.WriteLine("오류: 연결 문자열에서 계정 이름 또는 키를 추출할 수 없습니다.");
        return;
    }
    
    // 공유 키 자격 증명 생성
    StorageSharedKeyCredential credential = new StorageSharedKeyCredential(accountName, accountKey);
    
    // SAS 토큰이 유효한 시간 설정
    DateTimeOffset expiresOn = DateTimeOffset.UtcNow.AddDays(1); // 1일 후 만료
    
    // 컨테이너 SAS 토큰 생성
    BlobSasBuilder sasBuilder = new BlobSasBuilder
    {
        BlobContainerName = containerName,
        Resource = "c", // "c"는 Container를 의미
        StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5), // 5분 전부터 유효 (시계 오차 허용)
        ExpiresOn = expiresOn
    };
    
    // 권한 설정 (읽기 및 목록 조회 허용)
    sasBuilder.SetPermissions(BlobContainerSasPermissions.Read | BlobContainerSasPermissions.List);
    
    // SAS 토큰 생성
    string sasToken = sasBuilder.ToSasQueryParameters(credential).ToString();
    
    // SAS URL 생성
    string sasUrl = containerClient.Uri + "?" + sasToken;
    
    Console.WriteLine($"'{containerName}' 컨테이너에 대한 SAS 토큰이 생성되었습니다!");
    Console.WriteLine($"권한: 읽기 및 목록 조회");
    Console.WriteLine($"만료 시간: {expiresOn}");
    Console.WriteLine($"\nSAS URL: {sasUrl}");
    Console.WriteLine("\n이 URL을 사용하여 컨테이너의 모든 Blob을 나열하고 읽을 수 있습니다.");
}

이 코드는 컨테이너에 대한 SAS 토큰을 생성해. 이 토큰은 컨테이너 내의 모든 Blob을 나열하고 읽을 수 있는 권한을 부여하며, 1일 동안 유효해!

SAS 토큰을 사용하여 Blob에 접근하기

이제 생성한 SAS 토큰을 사용하여 Blob에 접근하는 방법을 알아보자:

static async Task AccessBlobWithSasTokenAsync(string blobName, string sasToken)
{
    // SAS 토큰을 사용하여 BlobClient 생성
    // 여기서는 계정 키가 필요하지 않음!
    Uri blobUri = new Uri($"https://{accountName}.blob.core.windows.net/{containerName}/{blobName}?{sasToken}");
    BlobClient blobClient = new BlobClient(blobUri);
    
    try
    {
        Console.WriteLine($"SAS 토큰을 사용하여 '{blobName}' Blob에 접근 중...");
        
        // Blob 속성 가져오기 (읽기 권한 테스트)
        BlobProperties properties = await blobClient.GetPropertiesAsync();
        
        Console.WriteLine("성공적으로 Blob에 접근했습니다!");
        Console.WriteLine($"Blob 크기: {FormatFileSize(properties.ContentLength)}");
        Console.WriteLine($"콘텐츠 타입: {properties.ContentType}");
        Console.WriteLine($"마지막 수정 시간: {properties.LastModified}");
        
        // 내용 다운로드 (텍스트 파일인 경우)
        if (properties.ContentType.Contains("text") || Path.GetExtension(blobName).ToLower() == ".txt")
        {
            BlobDownloadInfo download = await blobClient.DownloadAsync();
            
            using (StreamReader reader = new StreamReader(download.Content))
            {
                string content = await reader.ReadToEndAsync();
                Console.WriteLine("\nBlob 내용 (처음 100자):");
                Console.WriteLine(content.Length > 100 ? content.Substring(0, 100) + "..." : content);
            }
        }
        
        // 쓰기 작업 시도 (실패해야 함 - 읽기 전용 SAS)
        try
        {
            byte[] data = System.Text.Encoding.UTF8.GetBytes("This is a test.");
            using (MemoryStream stream = new MemoryStream(data))
            {
                await blobClient.UploadAsync(stream, overwrite: true);
            }
            Console.WriteLine("\n경고: 쓰기 작업이 성공했습니다. SAS 토큰에 쓰기 권한이 있습니다!");
        }
        catch (RequestFailedException ex) when (ex.Status == 403)
        {
            Console.WriteLine("\n예상대로 쓰기 작업이 실패했습니다. SAS 토큰에 쓰기 권한이 없습니다.");
        }
    }
    catch (RequestFailedException ex) when (ex.Status == 403)
    {
        Console.WriteLine($"오류: SAS 토큰에 필요한 권한이 없습니다. 상태 코드: {ex.Status}");
    }
    catch (RequestFailedException ex) when (ex.Status == 404)
    {
        Console.WriteLine($"오류: Blob을 찾을 수 없습니다. 상태 코드: {ex.Status}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"오류 발생: {ex.Message}");
    }
}

이 코드는 SAS 토큰을 사용하여 Blob에 접근하는 방법을 보여줘. 중요한 점은 이 코드에서는 스토리지 계정 키가 필요하지 않다는 거야! SAS 토큰만 있으면 Blob에 접근할 수 있어. 또한, 이 코드는 SAS 토큰의 권한을 테스트하기 위해 쓰기 작업을 시도하고, 읽기 전용 SAS 토큰의 경우 예상대로 실패하는지 확인해.

사용자 위임 SAS 토큰 생성하기

Azure AD(Active Directory) 자격 증명을 사용하여 SAS 토큰을 생성하는 방법도 있어. 이를 '사용자 위임 SAS'라고 해:

static async Task CreateUserDelegationSasAsync(string blobName)
{
    // 참고: 이 코드를 실행하려면 Azure.Identity 패키지가 필요하며,
    // Azure AD에 애플리케이션이 등록되어 있어야 합니다.
    
    // DefaultAzureCredential을 사용하여 Azure AD 인증
    DefaultAzureCredential credential = new DefaultAzureCredential();
    
    // BlobServiceClient 생성 (Azure AD 자격 증명 사용)
    BlobServiceClient blobServiceClient = new BlobServiceClient(
        new Uri($"https://{accountName}.blob.core.windows.net"),
        credential);
    
    // 컨테이너 클라이언트 가져오기
    BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    
    // Blob 클라이언트 가져오기
    BlobClient blobClient = containerClient.GetBlobClient(blobName);
    
    // 사용자 위임 키 가져오기 (7일 동안 유효)
    UserDelegationKey userDelegationKey = await blobServiceClient.GetUserDelegationKeyAsync(
        DateTimeOffset.UtcNow.AddMinutes(-5),
        DateTimeOffset.UtcNow.AddDays(7));
    
    // SAS 토큰이 유효한 시간 설정
    DateTimeOffset expiresOn = DateTimeOffset.UtcNow.AddHours(2); // 2시간 후 만료
    
    // Blob SAS 토큰 생성
    BlobSasBuilder sasBuilder = new BlobSasBuilder
    {
        BlobContainerName = containerName,
        BlobName = blobName,
        Resource = "b", // "b"는 Blob을 의미
        StartsOn = DateTimeOffset.UtcNow.AddMinutes(-5), // 5분 전부터 유효 (시계 오차 허용)
        ExpiresOn = expiresOn
    };
    
    // 권한 설정 (읽기만 허용)
    sasBuilder.SetPermissions(BlobSasPermissions.Read);
    
    // 사용자 위임 키를 사용하여 SAS 토큰 생성
    string sasToken = sasBuilder.ToSasQueryParameters(userDelegationKey, accountName).ToString();
    
    // SAS URL 생성
    string sasUrl = blobClient.Uri + "?" + sasToken;
    
    Console.WriteLine($"'{blobName}' Blob에 대한 사용자 위임 SAS 토큰이 생성되었습니다!");
    Console.WriteLine($"만료 시간: {expiresOn}");
    Console.WriteLine($"\nSAS URL: {sasUrl}");
}

이 코드는 Azure AD 자격 증명을 사용하여 사용자 위임 SAS 토큰을 생성해. 이 방법은 다음과 같은 장점이 있어:

1. 계정 키 불필요: 스토리지 계정 키를 코드에 포함하지 않아도 돼.
2. Azure AD 통합: Azure AD의 인증 및 권한 부여 기능을 활용할 수 있어.
3. 감사 및 추적: 어떤 사용자가 SAS 토큰을 생성했는지 추적할 수 있어.

이제 우리는 Azure Blob Storage의 보안 및 SAS 토큰에 대해 배웠어! SAS 토큰을 사용하면 스토리지 계정 키를 공유하지 않고도 특정 리소스에 대한 제한된 액세스 권한을 부여할 수 있어. 이는 마치 재능넷에서 다양한 재능을 안전하게 공유하는 것과 같아. 다음 단계에서는 성능 최적화 팁에 대해 알아볼 거야. 계속 따라와줘! 🚀

10. 성능 최적화 팁 🚀

자, 이제 우리는 Azure Blob Storage의 기본 기능부터 보안까지 다양한 측면을 배웠어. 하지만 클라우드 저장소를 효율적으로 사용하려면 성능 최적화도 중요해! 이건 마치 우리 창고에서 물건을 가장 빠르고 효율적으로 넣고 꺼내는 방법을 찾는 것과 같아. 최고의 성능을 얻기 위한 다양한 팁을 알아보자! 🏎️

1. 적절한 Blob 유형 선택하기

Azure Blob Storage는 세 가지 유형의 Blob을 제공해:

1. Block Blob: 텍스트나 이미지와 같은 일반적인 파일에 적합해. 최대 4.75TB까지 저장 가능해.
2. Append Blob: 로그 파일과 같이 데이터를 계속 추가하는 시나리오에 적합해.
3. Page Blob: 가상 머신 디스크와 같이 임의 접근이 필요한 대용량 파일에 적합해.

대부분의 경우 Block Blob이 가장 적합하지만, 특정 시나리오에서는 다른 유형이 더 효율적일 수 있어!

2. 병렬 업로드 및 다운로드 활용하기

대용량 파일을 처리할 때는 병렬 작업을 활용하면 성능을 크게 향상시킬 수 있어:

// 병렬 업로드 설정
BlobUploadOptions options = new BlobUploadOptions
{
    TransferOptions = new StorageTransferOptions
    {
        // 병렬 작업 수 설정 (CPU 코어 수에 따라 조정)
        MaximumConcurrency = Environment.ProcessorCount * 2,
        
        // 각 블록의 크기 설정 (파일 크기에 따라 조정)
        MaximumTransferSize = 8 * 1024 * 1024 // 8MB
    }
};

MaximumConcurrency는 동시에 실행할 수 있는 작업 수를 결정하고, MaximumTransferSize는 각 블록의 크기를 결정해. 이 값들을 환경과 파일 크기에 맞게 조정하면 최적의 성능을 얻을 수 있어!

3. 적절한 스토리지 계층 선택하기

Azure Blob Storage는 다양한 액세스 계층을 제공해:

1. Hot: 자주 액세스하는 데이터에 적합해. 저장 비용은 높지만 액세스 비용은 낮아.
2. Cool: 30일 이상 저장하지만 자주 액세스하지 않는 데이터에 적합해.
3. Archive: 거의 액세스하지 않고 장기간 보존해야 하는 데이터에 적합해.

데이터 액세스 패턴에 맞는 계층을 선택하면 비용을 최적화할 수 있어!

// Blob을 Cool 계층으로 설정
await blobClient.SetAccessTierAsync(AccessTier.Cool);

// Blob을 Archive 계층으로 설정
await blobClient.SetAccessTierAsync(AccessTier.Archive);

// Archive 계층에서 Hot 계층으로 복원 (시간이 걸림)
await blobClient.SetAccessTierAsync(AccessTier.Hot);

4. CDN(Content Delivery Network) 활용하기

전 세계 사용자에게 콘텐츠를 제공해야 한다면 Azure CDN을 활용하는 것이 좋아:

// CDN에서 사용할 컨테이너는 공개 액세스로 설정
await containerClient.SetAccessPolicyAsync(PublicAccessType.Blob);

// 그 후 Azure Portal에서 CDN 프로필 및 엔드포인트를 설정
// CDN 엔드포인트 원본으로 Blob Storage를 선택

CDN을 사용하면 사용자와 가까운 위치에서 콘텐츠를 제공하므로 지연 시간을 줄이고 성능을 향상시킬 수 있어!

5. 비동기 작업 활용하기

C#에서는 비동기 작업을 활용하여 애플리케이션의 응답성을 유지하면서 Blob Storage 작업을 수행할 수 있어:

// 여러 파일을 병렬로 업로드
public async Task UploadMultipleFilesAsync(string[] filePaths)
{
    // 각 파일에 대한 업로드 작업 생성
    List uploadTasks = new List();
    
    foreach (string filePath in filePaths)
    {
        // 각 파일에 대해 별도의 비동기 작업 시작
        Task uploadTask = UploadFileAsync(filePath);
        uploadTasks.Add(uploadTask);
    }
    
    // 모든 업로드 작업이 완료될 때까지 대기
    await Task.WhenAll(uploadTasks);
    
    Console.WriteLine($"모든 파일({filePaths.Length}개)이 성공적으로 업로드되었습니다!");
}

이 코드는 여러 파일을 병렬로 업로드하는 방법을 보여줘. Task.WhenAll을 사용하면 모든 작업이 완료될 때까지 효율적으로 대기할 수 있어!

6. 재시도 정책 구현하기

네트워크 문제나 일시적인 오류에 대비하여 재시도 정책을 구현하는 것이 좋아:

// Azure SDK의 기본 재시도 정책 사용
BlobClientOptions options = new BlobClientOptions
{
    Retry = {
        MaxRetries = 5,                     // 최대 재시도 횟수
        Delay = TimeSpan.FromSeconds(2),    // 초기 지연 시간
        MaxDelay = TimeSpan.FromSeconds(10),// 최대 지연 시간
        Mode = RetryMode.Exponential        // 지수 백오프 사용
    }
};

// 이 옵션을 사용하여 클라이언트 생성
BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString, options);

이 코드는 Azure SDK의 기본 재시도 정책을 구성하는 방법을 보여줘. 지수 백오프를 사용하면 재시도 간격이 점점 길어져 서버에 부담을 줄이면서도 결국에는 성공할 가능성을 높일 수 있어!

7. 대용량 파일 처리 전략

매우 큰 파일(수 GB 이상)을 처리할 때는 다음과 같은 전략을 고려해볼 수 있어:

// 대용량 파일을 청크로 나누어 업로드
public async Task UploadLargeFileInChunksAsync(string filePath, string blobName)
{
    // 블록 ID 목록
    List blockIds = new List();
    
    // 청크 크기 (4MB)
    int chunkSize = 4 * 1024 * 1024;
    
    // 파일 열기
    using (FileStream fileStream = File.OpenRead(filePath))
    {
        long fileSize = fileStream.Length;
        long position = 0;
        int blockNumber = 0;
        
        // BlobClient 가져오기
        BlobClient blobClient = containerClient.GetBlobClient(blobName);
        
        // 파일을 청크로 나누어 업로드
        while (position < fileSize)
        {
            // 현재 청크 크기 계산
            int currentChunkSize = (int)Math.Min(chunkSize, fileSize - position);
            
            // 청크 데이터 읽기
            byte[] buffer = new byte[currentChunkSize];
            await fileStream.ReadAsync(buffer, 0, currentChunkSize);
            
            // 블록 ID 생성 (Base64 인코딩된 문자열이어야 함)
            string blockId = Convert.ToBase64String(Encoding.UTF8.GetBytes($"block-{blockNumber:D6}"));
            blockIds.Add(blockId);
            
            // 블록 업로드
            using (MemoryStream memoryStream = new MemoryStream(buffer))
            {
                await blobClient.StageBlockAsync(blockId, memoryStream);
            }
            
            // 위치 및 블록 번호 업데이트
            position += currentChunkSize;
            blockNumber++;
            
            // 진행 상황 보고
            double percentage = (double)position / fileSize * 100;
            Console.Write($"\r업로드 중: {percentage:F2}% 완료");
        }
        
        // 모든 블록을 커밋하여 Blob 생성
        await blobClient.CommitBlockListAsync(blockIds);
        
        Console.WriteLine($"\n파일이 성공적으로 업로드되었습니다! 총 {blockNumber}개의 블록.");
    }
}

이 코드는 대용량 파일을 작은 청크로 나누어 업로드하는 방법을 보여줘. 이 방법은 다음과 같은 장점이 있어:

1. 메모리 효율성: 전체 파일을 메모리에 로드하지 않고 청크 단위로 처리해.
2. 재시작 가능성: 업로드가 중단되면 이미 업로드된 블록은 다시 업로드할 필요가 없어.
3. 병렬 처리 가능성: 청크를 병렬로 업로드하도록 확장할 수 있어.

8. 적절한 인덱싱 및 메타데이터 활용

많은 Blob을 관리할 때는 효율적인 검색을 위해 태그와 메타데이터를 활용하는 것이 좋아:

// 검색 가능한 태그 설정
IDictionary tags = new Dictionary
{
    { "category", "documents" },
    { "department", "finance" },
    { "year", "2025" }
};

await blobClient.SetTagsAsync(tags);

// 태그 기반 검색
string query = "\"category\" = 'documents' AND \"year\" = '2025'";
await foreach (TaggedBlobItem item in blobServiceClient.FindBlobsByTagsAsync(query))
{
    Console.WriteLine($"찾은 Blob: {item.BlobName}");
}

태그를 사용하면 SQL과 유사한 쿼리로 Blob을 빠르게 검색할 수 있어. 이는 특히 수천 개 이상의 Blob을 관리할 때 유용해!

이제 우리는 Azure Blob Storage의 성능을 최적화하는 다양한 방법을 배웠어! 이런 기법들을 활용하면 더 빠르고 효율적인 클라우드 저장소 솔루션을 구축할 수 있어. 마치 재능넷에서 다양한 재능을 효율적으로 관리하는 것처럼, 우리도 클라우드 저장소를 최적화할 수 있게 되었어. 다음 단계에서는 실전 예제를 통해 배운 내용을 종합해볼 거야. 계속 따라와줘! 🚀