Amazon S3에서 Azure Blob으로 직접 전송하기

Amazon S3
    │
    │ Download
    ▼
Local PC
    │
    │ Upload
    ▼
Azure Blob

┌──────────────────┐
│    Amazon S3     │
│                  │
│ Source Bucket    │
└────────┬─────────┘
         │
         │ Direct Transfer
         ▼
┌──────────────────┐
│   Azure Blob     │
│                  │
│ Target Container │
└──────────────────┘

Amazon S3

source-bucket
│
├── export/
│   ├── daily/          ◀ Selected
│   ├── monthly/
│   └── temporary/
│
├── logs/
└── backup/

Azure Blob

analytics-container
│
├── incoming/
│   └── daily/
│       ├── report-01.csv
│       ├── report-02.csv
│       └── report-03.csv
│
└── archive/

S3에 파일 생성
        │
        ▼
전송 조건 확인
        │
        ▼
대상 파일 선택
        │
        ▼
Azure Blob 전송
        │
        ▼
저장 결과 확인

Cloud Connections

Amazon S3
└── Source Bucket
    └── Read Files

Azure Blob Storage
└── Target Container
    └── Write Files

Source

Amazon S3
s3://data-source/export/

        │
        │ CSV / JSON / Media Files
        ▼

     Transfer Flow

        │
        ▼

Target

Azure Blob Storage
analytics/incoming/

                    ┌──▶ Azure Blob / analytics/
Amazon S3 ── Flow ──┤
                    ├──▶ Azure Blob / archive/
                    │
                    └──▶ Azure Blob / processing/

Amazon S3
     │
     ▼
Azure Blob
     │
     ├──────────────▶ Processing
     │
     ├──────────────▶ Notification
     │
     └──────────────▶ Next Transfer

                    Transfer Failed
                           │
            ┌──────────────┴──────────────┐
            │                             │
            ▼                             ▼
      Source 확인                    Target 확인
            │                             │
       S3 연결 상태                  Azure 연결 상태
       Bucket / 경로                 Container / 경로
       파일 접근 권한                파일 저장 권한
            │                             │
            └──────────────┬──────────────┘
                           ▼
                       환경 조정
                           │
                           ▼
                         Retry
                           │
                           ▼
                    Azure Blob 확인

import time


def transfer_objects(source, target, prefixes, target_prefix, action="overwrite"):
    transfer = api("POST", "/api/transfers/manual", {
        "sourceDevice": source,
        "targetDevice": target,
        "targetPath": target_prefix,
        "sourcePaths": prefixes,
        "sendAllFolder": True,
        "transferOptions": {"target-action": action},
    })
    return transfer["monitorId"]


def wait_transfer(monitor_id, timeout=14400, interval=5):
    deadline = time.time() + timeout
    while time.time() < deadline:
        detail = api("GET", f"/api/transfers/{monitor_id}") or {}
        if detail.get("status") in TERMINAL:
            return detail
        time.sleep(interval)
    raise TimeoutError(monitor_id)


monitor_id = transfer_objects("s3-src", "azure-dst", ["media/2026/09"], "archive/2026/09")
detail = wait_transfer(monitor_id)
print("completed:", detail.get("status") == STATUS_COMPLETE)

static String transferObjects(InnorixClient client, String source, String target,
        List<String> prefixes, String targetPrefix, String action) {
    Map<String, Object> transfer = client.apiObj("POST", "/api/transfers/manual", Json.newObj(
            "sourceDevice", source,
            "targetDevice", target,
            "targetPath", targetPrefix,
            "sourcePaths", prefixes,
            "sendAllFolder", true,
            "transferOptions", Json.newObj("target-action", action)), null);
    return Json.str(transfer, "monitorId");
}

static Map<String, Object> waitTransfer(InnorixClient client, String monitorId,
        long timeoutSec, long intervalSec) throws InterruptedException {
    long deadline = System.currentTimeMillis() + timeoutSec * 1000;
    while (System.currentTimeMillis() < deadline) {
        Map<String, Object> detail = client.apiObj("GET", "/api/transfers/" + monitorId, null, null);
        Integer status = Json.intOrNull(detail, "status");
        if (status != null && InnorixClient.TERMINAL.contains(status))
            return detail;
        Thread.sleep(intervalSec * 1000);
    }
    throw new RuntimeException("timeout: " + monitorId);
}

async function transferObjects(source, target, prefixes, targetPrefix, action = "overwrite") {
  const transfer = await api("POST", "/api/transfers/manual", {
    sourceDevice: source,
    targetDevice: target,
    targetPath: targetPrefix,
    sourcePaths: prefixes,
    sendAllFolder: true,
    transferOptions: { "target-action": action },
  });
  return transfer.monitorId;
}

async function waitTransfer(monitorId, { timeout = 14400, interval = 5 } = {}) {
  const deadline = Date.now() + timeout * 1000;
  while (Date.now() < deadline) {
    const detail = (await api("GET", `/api/transfers/${monitorId}`)) || {};
    if (TERMINAL.has(detail.status)) return detail;
    await new Promise((r) => setTimeout(r, interval * 1000));
  }
  throw new Error(`timeout: ${monitorId}`);
}

const monitorId = await transferObjects("s3-src", "azure-dst", ["media/2026/09"], "archive/2026/09");
const detail = await waitTransfer(monitorId);
console.log("completed:", detail.status === STATUS_COMPLETE);

static async Task<string> TransferObjectsAsync(InnorixClient client, string source, string target,
    IEnumerable<string> prefixes, string targetPrefix, string action = "overwrite")
{
    var transfer = await client.ApiObjAsync("POST", "/api/transfers/manual", new JsonObject
    {
        ["sourceDevice"] = source,
        ["targetDevice"] = target,
        ["targetPath"] = targetPrefix,
        ["sourcePaths"] = J.ArrOfStrings(prefixes),
        ["sendAllFolder"] = true,
        ["transferOptions"] = new JsonObject { ["target-action"] = action },
    });
    return J.Str(transfer, "monitorId");
}

static async Task<JsonObject> WaitTransferAsync(InnorixClient client, string monitorId,
    int timeoutSec = 14400, int intervalSec = 5)
{
    DateTime deadline = DateTime.UtcNow.AddSeconds(timeoutSec);
    while (DateTime.UtcNow < deadline)
    {
        JsonObject detail = await client.ApiObjAsync("GET", 
quot;/api/transfers/{monitorId}", null, null);
        int? status = J.IntOrNull(detail, "status");
        if (status != null && InnorixClient.Terminal.Contains(status.Value))
            return detail;
        await Task.Delay(intervalSec * 1000);
    }
    throw new TimeoutException(monitorId);
}

Amazon S3 (s3-src) — 프리픽스 지정
   ↓
전송 생성 (overwrite) → 종료 상태까지 대기
   ↓
Azure Blob (azure-dst) — 대상 프리픽스에 객체 반영
   ↓
실패 객체만 재시도