전송 만들기

이 페이지에서는 전송 작업을 만들고 시작하는 방법을 보여줍니다.

소스 및 대상(싱크라고도 함)이 Storage Transfer Service에서 지원되는지 확인하려면 지원되는 소스 및 싱크를 참조하세요.

에이전트 및 에이전트 풀

소스 및 대상에 따라 에이전트 풀을 만들어 구성하고 소스 또는 대상에 대한 액세스 권한이 있는 머신에 에이전트를 설치해야 할 수도 있습니다.

  • Amazon S3, Microsoft Azure, URL 목록 또는 Cloud Storage에서 Cloud Storage로 전송 시 에이전트와 에이전트 풀이 필요하지 않습니다.

  • 해당 소스 또는 대상이 파일 시스템이거나 S3 호환 스토리지의 전송은 에이전트 및 에이전트 풀이 필요하지 않습니다. 자세한 내용은 에이전트 풀 관리를 참조하세요.

시작하기 전에

전송을 구성하기 전에 다음에 대한 액세스를 구성했는지 확인하세요.

gcloud 명령어를 사용하는 경우 gcloud CLI를 설치합니다.

전송 만들기

전송 작업 이름에 개인 식별 정보(PII) 또는 보안 데이터와 같은 민감한 정보를 포함하지 마세요. 리소스 이름은 다른 Google Cloud 리소스의 이름으로 전파될 수 있으며 프로젝트 외부의 Google 내부 시스템에 노출될 수 있습니다.

Google Cloud 콘솔

  1. Google Cloud 콘솔의 Storage Transfer Service 페이지로 이동합니다.

    Storage Transfer Service로 이동

  2. 전송 작업 만들기를 클릭합니다. 전송 작업 만들기 페이지가 표시됩니다.

  3. 소스를 선택합니다.

    Cloud Storage

    소스 계정과 대상 버킷을 선택하려면 사용자 계정에 storage.buckets.get 권한이 있어야 합니다. 또는 버킷 이름을 직접 입력할 수 있습니다. 자세한 내용은 액세스 문제 해결을 참조하세요.

    1. 소스 유형에서 Cloud Storage를 선택합니다.

    2. 대상 유형을 선택합니다.

    3. 대상이 Cloud Storage인 경우 예약 모드를 선택합니다. 일괄 전송은 일회성 또는 예약된 방식으로 실행됩니다. 이벤트 기반 전송은 소스가 추가되거나 수정될 때 소스를 지속적으로 모니터링하고 전송합니다.

      이벤트 기반 전송을 구성하려면 이벤트 기반 전송의 안내를 따르세요.

    4. 다음 단계를 클릭합니다.

    5. 다음 중 하나를 수행하여 버킷과 해당 버킷의 폴더(선택사항)를 선택합니다.

      • 버킷 또는 폴더 필드에 프리픽스 gs:// 없이 기존 Cloud Storage 버킷 이름과 경로를 입력합니다. 예를 들면 my-test-bucket/path/to/files입니다. 다른 프로젝트의 Cloud Storage 버킷을 지정하려면 버킷 이름 필드에 이름을 정확하게 입력합니다.

      • 찾아보기를 클릭한 후 버킷을 선택하여 프로젝트의 기존 버킷 목록을 선택합니다.

        찾아보기를 클릭할 때 프로젝트 ID를 클릭하고 새 프로젝트 ID와 버킷을 선택하여 다른 프로젝트에서 버킷을 선택할 수 있습니다.

      • 새 버킷을 만들려면 새 버킷 만들기를 클릭합니다.

    6. 이벤트 기반 전송인 경우 다음 형식으로 Pub/Sub 구독 이름을 입력합니다.

      projects/PROJECT_NAME/subscriptions/SUBSCRIPTION_ID
      
    7. 원하는 경우 프리픽스를 기준으로 객체를 필터링하거나 최종 수정 날짜를 기준으로 객체를 필터링하도록 선택합니다. 폴더를 소스 위치로 지정한 경우 프리픽스 필터는 해당 폴더를 기준으로 합니다. 예를 들어 소스가 my-test-bucket/path/인 경우 file의 포함 필터는 my-test-bucket/path/file로 시작하는 모든 파일을 포함합니다.
    8. 다음 단계를 클릭합니다.

    Amazon S3

    1. 소스 유형에서 Amazon S3를 선택합니다.

    2. 대상 유형으로 Google Cloud Storage를 선택합니다.

    3. 예약 모드를 선택합니다. 일괄 전송은 일회성 또는 예약된 방식으로 실행됩니다. 이벤트 기반 전송은 소스가 추가되거나 수정될 때 소스를 지속적으로 모니터링하고 전송합니다.

      이벤트 기반 전송을 구성하려면 이벤트 기반 전송의 안내를 따르세요.

    4. 다음 단계를 클릭합니다.

    5. 버킷 또는 폴더 이름 필드에 소스 버킷 이름을 입력합니다.

      버킷 이름은 AWS 관리 콘솔에 나타나는 이름입니다.

    6. S3에서 CloudFront 배포를 사용하여 전송하는 경우 CloudFront domain 필드에 배포 도메인 이름을 입력하세요. 예를 들면 https://dy1h2n3l4ob56.cloudfront.net입니다. CloudFront 배포를 구성하려면 CloudFront를 통해 S3에서 전송을 참조하세요.

    7. Amazon Web Services(AWS) 인증 방법을 선택합니다. ID 제휴를 위해 AWS 액세스 키 또는 Amazon 리소스 이름(ARN)을 제공할 수 있습니다.

      • 액세스 키: 액세스 키 ID 필드에 액세스 키를 입력하고 보안 비밀 액세스 키 필드에 액세스 키와 연관된 보안 비밀을 입력합니다.

      • ARN: 다음 구문을 사용해서 AWS IAM 역할 ARN 필드에 ARN을 입력합니다.

        arn:aws:iam::ACCOUNT:role/ROLE-NAME-WITH-PATH
        

        각 항목의 의미는 다음과 같습니다.

        • ACCOUNT: 하이픈이 없는 AWS 계정 ID입니다.
        • ROLE-NAME-WITH-PATH: 경로가 포함된 AWS 역할 이름입니다.

        ARN에 관한 자세한 내용은 IAM ARN을 참조하세요.

    8. 이벤트 기반 전송인 경우 다음 형식을 사용하는 Amazon SQS 큐 ARN을 입력합니다.

      arn:aws:sqs:us-east-1:1234567890:event-queue
      
    9. 원하는 경우 프리픽스를 기준으로 객체를 필터링하거나 최종 수정 날짜를 기준으로 객체를 필터링하도록 선택합니다. 폴더를 소스 위치로 지정한 경우 프리픽스 필터는 해당 폴더를 기준으로 합니다. 예를 들어 소스가 my-test-bucket/path/인 경우 file의 포함 필터는 my-test-bucket/path/file로 시작하는 모든 파일을 포함합니다.
    10. 다음 단계를 클릭합니다.

    S3 호환 스토리지

    1. 소스 유형에서 S3 호환 객체 스토리지를 선택합니다.

    2. 다음 단계를 클릭합니다.

    3. 이 전송에 필요한 정보를 지정합니다.

      1. 이 전송에 대해 구성한 에이전트 풀을 선택합니다.

      2. 엔드포인트를 기준으로 버킷 이름을 입력합니다. 예를 들어 데이터가 다음 위치에 있는 경우:

        https://us-east-1.example.com/folder1/bucket_a

        folder1/bucket_a 입력

      3. 엔드포인트를 입력합니다. 프로토콜(http:// 또는 https://)을 포함하지 마세요. 이전 단계의 예시의 경우 다음과 같이 입력합니다.

        us-east-1.example.com

    4. 이 전송의 선택적 속성을 지정합니다.

      1. 요청 서명에 사용할 서명 리전을 입력합니다. 소스에 서명 리전이 필요하지 않으면 이 필드를 비워 둡니다.

      2. 이 요청에 대한 서명 프로세스를 선택합니다.

      3. 주소 지정 스타일을 선택합니다. 이에 따라 버킷 이름이 경로 스타일로 제공되는지 여부(예: https://s3.region.example.com/bucket-name/key-name) 또는 가상 호스팅 스타일(예: https://bucket-name.s3.region.example.com/key-name)입니다. 자세한 내용은 Amazon 문서의 [Virtual hosting of buckets]를 참조하세요.

      4. 네트워크 프로토콜을 선택합니다.

      5. 사용할 목록 API 버전을 선택합니다. 자세한 내용은 ListObjectsV2ListObjects 문서를 참조하세요.

    5. 다음 단계를 클릭합니다.

    Microsoft Azure Blob Storage

    1. 소스 유형에서 Azure Blob Storage 또는 Data Lake Storage Gen2를 선택합니다.

    2. 다음 단계를 클릭합니다.

    3. 다음 사항을 지정합니다.

      1. 스토리지 계정 이름 — 소스 Microsoft Azure Storage 계정 이름입니다.

        스토리지 계정 이름은 모든 서비스 > 스토리지 > 스토리지 계정의 Microsoft Azure Storage 포털에 표시됩니다.

      2. 컨테이너 이름 — Microsoft Azure Storage 컨테이너 이름입니다.

        컨테이너 이름은 스토리지 탐색기 > Blob 컨테이너의 Microsoft Azure Storage 포털에 표시됩니다.

      3. 공유 액세스 서명(SAS) — 저장된 액세스 정책에서 만든 Microsoft Azure Storage SAS 토큰입니다. 자세한 내용은 공유 액세스 서명(SAS)을 사용하여 Azure Storage 리소스에 대한 제한된 액세스 권한 부여를 참조하세요.

        SAS 토큰의 기본 만료 시간은 8시간입니다. SAS 토큰을 만들 때 전송을 성공적으로 완료할 수 있도록 적절한 만료 시간을 설정해야 합니다.
    4. 원하는 경우 프리픽스를 기준으로 객체를 필터링하거나 최종 수정 날짜를 기준으로 객체를 필터링하도록 선택합니다. 폴더를 소스 위치로 지정한 경우 프리픽스 필터는 해당 폴더를 기준으로 합니다. 예를 들어 소스가 my-test-bucket/path/인 경우 file의 포함 필터는 my-test-bucket/path/file로 시작하는 모든 파일을 포함합니다.
    5. 다음 단계를 클릭합니다.

    파일 시스템

    1. 소스 유형에서 POSIX 파일 시스템을 선택합니다.

    2. 대상 유형을 선택하고 다음 단계를 클릭합니다.

    3. 기존 에이전트 풀을 선택하거나 에이전트 풀 만들기를 선택하고 안내에 따라 새 풀을 만듭니다.

    4. 파일 시스템 디렉터리의 정규화된 경로를 지정합니다.

    5. 다음 단계를 클릭합니다.

    HDFS

    HDFS에서 Cloud Storage로 전송을 참조하세요.

    URL 목록

    1. 소스 유형에서 URL 목록을 선택하고 다음 단계를 클릭합니다.

    2. TSV 파일의 URL에서 탭으로 구분된 값(TSV) 파일의 URL을 입력합니다. TSV 파일을 만드는 방법에 대한 자세한 내용은 URL 목록 만들기를 참조하세요.

    3. 원하는 경우 프리픽스를 기준으로 객체를 필터링하거나 최종 수정 날짜를 기준으로 객체를 필터링하도록 선택합니다. 폴더를 소스 위치로 지정한 경우 프리픽스 필터는 해당 폴더를 기준으로 합니다. 예를 들어 소스가 my-test-bucket/path/인 경우 file의 포함 필터는 my-test-bucket/path/file로 시작하는 모든 파일을 포함합니다.
    4. 다음 단계를 클릭합니다.

  4. 대상 위치 선택:

    Cloud Storage

    1. 버킷 또는 폴더 필드에 대상 버킷과 폴더 이름(선택사항)을 입력하거나 찾아보기를 클릭하여 현재 프로젝트의 기존 목록에서 버킷을 선택합니다. 새 버킷을 만들려면 새 버킷 만들기를 클릭합니다.

    2. 다음 단계를 클릭합니다.

    3. 전송 작업의 설정을 선택합니다. 일부 옵션은 특정 소스/싱크 조합에만 사용할 수 있습니다.

      1. 설명 필드에 전송 설명을 입력합니다. 작업을 구분할 수 있도록 의미 있고 고유한 설명을 입력하는 것이 좋습니다.

      2. 메타데이터 옵션에서 기본 옵션을 사용하도록 선택하거나 옵션 보기 및 선택을 클릭하여 지원되는 모든 메타데이터의 값을 지정합니다. 자세한 내용은 메타데이터 보존을 참조하세요.

      3. 덮어쓸 시점에서 다음 중 하나를 선택합니다.

        • 다른 경우: 이름이 같은 소스 파일에 다른 Etag 또는 체크섬 값이 있는 경우 대상 파일을 덮어씁니다.

        • 항상: 소스 파일 이름이 같으면 동일하더라도 항상 대상 파일을 덮어씁니다.

      4. 삭제 시점에서 다음 중 하나를 선택합니다.

        • 삭제 안함: 소스 또는 대상 위치에서 파일을 삭제하지 않습니다.

        • 전송 후 소스에서 파일 삭제: 파일이 대상으로 전송된 후 소스에서 파일을 삭제합니다.

        • 소스에도 없는 경우 대상 위치에서 파일 삭제: 대상 Cloud Storage 버킷의 파일이 소스에도 없는 경우 Cloud Storage 버킷에서 파일을 삭제합니다.

          이 옵션을 사용하면 대상 Cloud Storage 버킷이 소스와 정확하게 일치합니다.

      5. 알림 옵션에서 Pub/Sub 주제 및 알림을 받을 이벤트를 선택합니다. 자세한 내용은 Pub/Sub 알림을 참조하세요.

    4. 다음 단계를 클릭합니다.

    파일 시스템

    1. 기존 에이전트 풀을 선택하거나 에이전트 풀 만들기를 선택하고 안내에 따라 새 풀을 만듭니다.

    2. 정규화된 대상 디렉터리 경로를 지정합니다.

    3. 다음 단계를 클릭합니다.

  5. 예약 옵션을 선택합니다.

    1. 한 번 실행 드롭다운 목록에서 다음 중 하나를 선택합니다.

      • 한 번 실행: 선택한 시간에 단일 전송을 실행합니다.

      • 매일 실행: 선택한 시점부터 매일 전송을 실행합니다.

        선택사항인 종료일을 입력하거나 종료일을 비워 두어 전송을 계속 실행할 수 있습니다.

      • 매주 실행: 선택한 시간부터 매주 전송을 실행합니다.

      • 커스텀 빈도로 실행: 선택한 빈도로 전송을 실행합니다. 시간, 또는 라는 정기적인 간격으로 전송을 반복하도록 선택할 수 있습니다.

        선택사항인 종료일을 입력하거나 종료일을 비워 두어 전송을 계속 실행할 수 있습니다.

    2. 지금 시작 드롭다운 목록에서 다음 중 하나를 선택합니다.

      • 지금 시작: 만들기를 클릭한 후 전송을 시작합니다.

      • 시작일: 선택한 날짜 및 시간에 전송을 시작합니다. 캘린더를 클릭하여 시작일을 선택할 캘린더를 표시합니다.

    3. 전송 작업을 만들려면 만들기를 클릭합니다.

gcloud CLI

새 전송 작업을 만들려면 gcloud transfer jobs create 명령어를 사용합니다. 일정 또는 --do-not-run이 지정되지 않은 한, 새 작업을 만들면 지정된 전송이 시작됩니다.

gcloud transfer jobs create \
  SOURCE DESTINATION

각 항목의 의미는 다음과 같습니다.

  • SOURCE는 이 전송의 데이터 소스입니다. 각 소스의 형식은 다음과 같습니다.

    • Cloud Storage: gs://BUCKET_NAME. 특정 폴더에서 전송하려면 후행 슬래시를 포함하여 gs://BUCKET_NAME/FOLDER_PATH/를 지정합니다.
    • Amazon S3: s3://BUCKET_NAME/FOLDER_PATH
    • S3 호환 스토리지: s3://BUCKET_NAME. 버킷 이름은 엔드포인트를 기준으로 합니다. 예를 들어 데이터가 https://us-east-1.example.com/folder1/bucket_a에 있으면 s3://folder1/bucket_a를 입력합니다.
    • Microsoft Azure Storage: https://myaccount.blob.core.windows.net/CONTAINER_NAME
    • URL 목록: https://PATH_TO_URL_LIST 또는 http://PATH_TO_URL_LIST
    • POSIX 파일 시스템: posix:///PATH. 에이전트 호스트 머신 루트의 절대 경로여야 합니다.
    • HDFS: hdfs:///PATH
  • DESTINATION은 다음 중 하나입니다.

    • Cloud Storage: gs://BUCKET_NAME. 특정 디렉터리로 전송하려면 후행 슬래시를 포함하여 gs://BUCKET_NAME/FOLDER_PATH/를 지정합니다.
    • POSIX 파일 시스템: posix:///PATH. 에이전트 호스트 머신 루트의 절대 경로여야 합니다.

전송에 전송 에이전트가 필요한 경우 다음 옵션을 사용할 수 있습니다.

  • --source-agent-pool은 이 전송에 사용할 소스 에이전트 풀을 지정합니다. 파일 시스템에서 시작된 전송에 필요합니다.

  • --destination-agent-pool은 이 전송에 사용할 대상 에이전트 풀을 지정합니다. 파일 시스템으로 전송하는 데 필요합니다.

  • --intermediate-storage-path는 Cloud Storage 버킷의 경로이며 gs://my-intermediary-bucket 형식입니다. 두 파일 시스템 간 전송에 필요합니다. 중간 버킷 만들기에 대한 자세한 내용은 Cloud Storage 버킷을 중개자로 만들기를 참조하세요.

추가로 선택할 수 있는 옵션은 다음과 같습니다.

  • --source-creds-file은 사용자 머신에서 전송 소스의 AWS 또는 Azure 사용자 인증 정보가 포함된 로컬 파일에 대한 상대 경로를 지정합니다. 사용자 인증 정보의 파일 형식 지정 정보는 TransferSpec 참조를 확인하세요.

  • --do-not-run은 명령어를 제출할 때 Storage Transfer Service가 작업을 실행하지 못하도록 방지합니다. 작업을 실행하려면 이를 업데이트해서 일정을 추가하거나 jobs run을 사용해서 수동으로 시작합니다.

  • --manifest-file은 소스에서 전송할 파일 목록이 포함된 Cloud Storage의 CSV 파일 경로를 지정합니다. 매니페스트 파일 형식 지정은 매니페스트를 사용하여 특정 파일 또는 객체 전송을 참조하세요.

  • 작업 정보: --name, --description, --source-creds-file을 지정할 수 있습니다.

  • 일정: --schedule-starts, --schedule-repeats-every, --schedule-repeats-until, --do-not-run을 지정합니다.

  • 객체 조건: 조건을 사용해서 전송되는 객체를 결정합니다. 여기에는 --include-prefixes--exclude-prefixes--include-modified-[before | after]-[absolute | relative]의 시간 기준 조건이 포함됩니다. 소스로 폴더를 지정한 경우 프리픽스 필터는 해당 폴더를 기준으로 합니다. 자세한 내용은 프리픽스로 소스 객체 필터링을 참조하세요.

    객체 조건은 파일 시스템과 관련된 전송에서 지원되지 않습니다.

  • 전송 옵션: 대상 파일(--overwrite-when=different 또는always)을 덮어쓸지 여부와 전송 중 또는 전송 후에 특정 파일을 삭제할지 여부(--delete-from=destination-if-unique 또는source-after-transfer)를 지정하고, 보존할 메타데이터 값(--preserve-metadata)을 지정하며, 필요한 경우 전송된 객체에 스토리지 클래스를 선택적으로 설정할 수 있습니다(--custom-storage-class).

  • 알림: --notification-pubsub-topic, --notification-event-types, --notification-payload-format으로 Pub/Sub 전송 알림을 구성합니다.

  • Cloud Logging: 에이전트리스 전송 또는 S3 호환 소스의 전송에 대해 --log-actions--log-action-states를 사용하여 Cloud Logging을 사용 설정합니다. 자세한 내용은 Storage Transfer Service의 Cloud Logging을 참조하세요.

또한 S3 호환 소스의 전송에 다음 옵션이 사용됩니다.

  • --source-endpoint(필수)는 스토리지 시스템의 엔드포인트를 지정합니다. 예를 들면 s3.example.com입니다. 올바른 형식을 제공업체에 문의하세요. 프로토콜(http:// 또는 https://)을 지정하지 마세요.
  • --source-signing-region은 요청에 서명할 리전을 지정합니다. 스토리지 제공업체에 서명 리전이 필요하지 않으면 이 플래그를 생략합니다.
  • --source-auth-method는 사용할 인증 방법을 지정합니다. 유효한 값은 AWS_SIGNATURE_V2 또는 AWS_SIGNATURE_V4입니다. 자세한 내용은 Amazon의 SigV4SigV2 문서를 참조하세요.
  • --source-request-model은 사용할 주소 지정 스타일을 지정합니다. 유효한 값은 PATH_STYLE 또는 VIRTUAL_HOSTED_STYLE입니다. 경로 스타일은 https://s3.example.com/BUCKET_NAME/KEY_NAME 형식을 사용합니다. 가상 호스트 스타일에는 `https://BUCKET_NAME.s3.example.com/KEY_NAME 형식이 사용됩니다.
  • --source-network-protocol은 에이전트가 이 작업에 사용해야 하는 네트워크 프로토콜을 지정합니다. 유효한 값은 HTTP 또는 HTTPS입니다.
  • --source-list-api는 버킷에서 객체를 반환하기 위한 S3 Listing API 버전을 지정합니다. 유효한 값은 LIST_OBJECTS 또는 LIST_OBJECTS_V2입니다. 자세한 내용은 Amazon의 ListObjectsV2ListObjects 문서를 참조하세요.

모든 옵션을 보려면 gcloud transfer jobs create --help를 실행하거나 gcloud 참조 문서를 참조하세요.

Examples

Amazon S3에서 Cloud Storage로 전송

다음 명령어를 실행하여 지난 1일 동안 수정된 데이터를 s3://my-s3-bucket에서 my-storage-bucket이라는 Cloud Storage 버킷으로 이동하는 일일 전송 작업을 만듭니다.

gcloud transfer jobs create \
  s3://my-s3-bucket gs://my-storage-bucket \
  --source-creds-file=/examplefolder/creds.txt \
  --include-modified-after-relative=1d \
  --schedule-repeats-every=1d

Cloud Storage에 대한 S3 호환 스토리지

S3 호환 소스에서 Cloud Storage 버킷으로 전송하려면 다음 안내를 따르세요.

gcloud transfer jobs create s3://my-s3-compat-bucket gs://my-storage-bucket \
  --source-agent-pool=my-source-agent-pool
  --source-endpoint=us-east-1.example.com/ \
  --source-auth-method=AWS_SIGNATURE_V2 \
  --source-request-model=PATH_STYLE \
  --source-network-protocol=HTTPS \
  --source-list-api=LIST_OBJECTS_V2

파일 시스템 - Cloud Storage

파일 시스템에서 Cloud Storage 버킷으로 전송하려면 다음을 지정합니다.

gcloud transfer jobs create \
  posix:///tmp/source gs://my-storage-bucket \
  --source-agent-pool=my-source-agent-pool

Cloud Storage - 파일 시스템

Cloud Storage 버킷에서 파일 시스템으로 전송하려면 다음을 지정합니다.

gcloud transfer jobs create \
  gs://my-storage-bucket posix:///tmp/destination \
  --destination-agent-pool=my-destination-agent-pool

파일 시스템 - 파일 시스템

두 파일 시스템 간에 전송하려면 소스 에이전트 풀, 대상 에이전트 풀, 데이터가 통과하는 중간 Cloud Storage 버킷을 지정해야 합니다.

중간 버킷에 대한 자세한 내용은 Cloud Storage 버킷을 중개자로 만들기를 참조하세요.

그런 다음 transfer jobs create를 호출할 때 다음 리소스 3개를 지정합니다.

gcloud transfer jobs create \
  posix:///tmp/source/on/systemA posix:///tmp/destination/on/systemB \
  --source-agent-pool=source_agent_pool \
  --destination-agent-pool=destination_agent_pool \
  --intermediate-storage-path=gs://my-intermediary-bucket

REST

다음 샘플에서는 REST API를 통해 Storage Transfer Service를 사용하는 방법을 보여줍니다.

Storage Transfer Service API를 사용하여 전송 작업을 구성하거나 편집할 때 시간은 UTC여야 합니다. 전송 작업 일정을 지정하는 방법에 대한 자세한 내용은 일정을 참조하세요.

Cloud Storage 버킷 간의 전송

이 예시에서는 하나의 Cloud Storage 버킷에서 다른 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다. 예를 들어 데이터를 다른 위치의 버킷으로 이동할 수 있습니다.

transferJobs create를 사용하는 요청:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME"
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }
}
응답:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "gcsDataSource": {
                  "bucketName": "GCS_SOURCE_NAME",
              },
              "gcsDataSink": {
                  "bucketName": "GCS_NEARLINE_SINK_NAME"
              },
              "objectConditions": {
                  "minTimeElapsedSinceLastModification": "2592000.000s"
              },
              "transferOptions": {
                  "deleteObjectsFromSourceAfterTransfer": true
              }
          }
      }
  ]
}

Amazon S3에서 Cloud Storage로 이전

이 예시에서는 파일을 Amazon S3에서 Cloud Storage 버킷으로 이동하는 방법을 학습합니다. 데이터를 Amazon S3에서 Cloud Storage로 이동할 때 발생하는 영향을 파악하려면 Amazon S3에 대한 액세스 구성가격 책정을 검토합니다.

전송 작업을 만들 때 Amazon S3 버킷 소스 이름에 bucketNames3:// 접두사를 포함하지 마세요.

transferJobs create를 사용하는 요청:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "scheduleEndDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "awsAccessKey": {
              "accessKeyId": "AWS_ACCESS_KEY_ID",
              "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}
응답:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2015-01-01T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2015-01-01T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "scheduleEndDate": {
                  "day": 1,
                  "month": 1,
                  "year": 2015
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "awsS3DataSource": {
                  "bucketName": "AWS_SOURCE_NAME"
              },
              "gcsDataSink": {
                  "bucketName": "GCS_SINK_NAME"
              },
              "objectConditions": {},
              "transferOptions": {}
          }
      }
  ]
}

CloudFront 배포를 통해 S3에서 전송하는 경우 배포 도메인 이름을 transferSpec.awsS3DataSource.cloudfrontDomain 필드 값으로 지정합니다.

"transferSpec": {
  "awsS3DataSource": {
    "bucketName": "AWS_SOURCE_NAME",
    "cloudfrontDomain": "https://dy1h2n3l4ob56.cloudfront.net",
    "awsAccessKey": {
      "accessKeyId": "AWS_ACCESS_KEY_ID",
      "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
    }
  },
  ...
}

Microsoft Azure Blob Storage와 Cloud Storage 간 전송

이 예시에서는 Microsoft Azure Storage 공유 액세스 서명(SAS) 토큰을 사용하여 Microsoft Azure Storage에서 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다.

Microsoft Azure Storage SAS에 대한 자세한 내용은 공유 액세스 서명(SAS)을 사용하여 Azure Storage 리소스에 대한 제한된 액세스 권한 부여를 참조하세요.

시작하기 전에 Microsoft Azure Storage 액세스 구성가격 책정을 검토하여 Microsoft Azure Storage에서 Cloud Storage로 데이터를 이동할 때 발생하는 영향을 알아봅니다.

transferJobs create를 사용하는 요청:

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 14,
          "month": 2,
          "year": 2020
      },
      "scheduleEndDate": {
          "day": 14
          "month": 2,
          "year": 2020
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "azureBlobStorageDataSource": {
          "storageAccount": "AZURE_SOURCE_NAME",
          "azureCredentials": {
              "sasToken": "AZURE_SAS_TOKEN",
          },
          "container": "AZURE_CONTAINER",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}
응답:
200 OK
{
  "transferJob": [
      {
          "creationTime": "2020-02-14T01:01:00.000000000Z",
          "description": "YOUR DESCRIPTION",
          "name": "transferJobs/JOB_ID",
          "status": "ENABLED",
          "lastModificationTime": "2020-02-14T01:01:00.000000000Z",
          "projectId": "PROJECT_ID",
          "schedule": {
              "scheduleStartDate": {
                  "day": 14
                  "month": 2,
                  "year": 2020
              },
              "scheduleEndDate": {
                  "day": 14,
                  "month": 2,
                  "year": 2020
              },
              "startTimeOfDay": {
                  "hours": 1,
                  "minutes": 1
              }
          },
          "transferSpec": {
              "azureBlobStorageDataSource": {
                  "storageAccount": "AZURE_SOURCE_NAME",
                  "azureCredentials": {
                      "sasToken": "AZURE_SAS_TOKEN",
                  },
                  "container": "AZURE_CONTAINER",
              },
              "objectConditions": {},
              "transferOptions": {}
          }
      }
  ]
}

파일 시스템에서 전송

이 예시에서는 POSIX 파일 시스템에서 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다.

posixDataSource와 함께 transferJobs.create를 사용합니다.

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
 "name":"transferJobs/sample_transfer",
 "description": "My First Transfer",
 "status": "ENABLED",
 "projectId": "my_transfer_project_id",
 "schedule": {
     "scheduleStartDate": {
         "year": 2022,
         "month": 5,
         "day": 2
     },
     "startTimeOfDay": {
         "hours": 22,
         "minutes": 30,
         "seconds": 0,
         "nanos": 0
     }
     "scheduleEndDate": {
         "year": 2022,
         "month": 12,
         "day": 31
     },
     "repeatInterval": {
         "259200s"
     },
 },
 "transferSpec": {
     "posixDataSource": {
          "rootDirectory": "/bar/",
     },
     "sourceAgentPoolName": "my_example_pool",
     "gcsDataSink": {
          "bucketName": "destination_bucket"
          "path": "foo/bar/"
     },
  }
}

schedule 필드는 선택사항입니다. 이 필드가 포함되지 않은 경우 전송 작업은 transferJobs.run 요청으로 시작해야 합니다.

작업을 만든 후 전송 상태를 확인하려면 transferJobs.get을 사용합니다.

GET https://storagetransfer.googleapis.com/v1/transferJobs/sample_transfer?project_id=my_transfer_project_id

소스 및 대상 경로 지정

소스 및 대상 경로를 사용하면 Cloud Storage 버킷으로 데이터를 전송할 때 소스 및 대상 디렉터리를 지정할 수 있습니다. 예를 들어 file1.txtfile2.txt 파일이 있고 B라는 Cloud Storage 버킷이 있다고 가정합니다. my-stuff라는 대상 경로를 설정하면 전송이 완료된 후 파일은 gs://B/my-stuff/file1.txtgs://B/my-stuff/file2.txt에 있습니다.

소스 경로 지정

전송 작업 생성 시 소스 경로를 지정하려면 TransferSpec 사양의 gcsDataSource 필드에 path 필드를 추가합니다.

{
gcsDataSource: {
  bucketName: "SOURCE_BUCKET",
  path: "SOURCE_PATH/",
},
}

예를 들면 다음과 같습니다.

  • SOURCE_BUCKET: 소스 Cloud Storage 버킷
  • SOURCE_PATH: 소스 Cloud Storage 경로

대상 경로 지정

전송 작업 생성 시 대상 폴더를 지정하려면 TransferSpec 사양의 gcsDataSink 필드에 path 필드를 추가합니다.

{
gcsDataSink: {
  bucketName: "DESTINATION_BUCKET",
  path: "DESTINATION_PATH/",
},
}

예를 들면 다음과 같습니다.

  • DESTINATION_BUCKET: 대상 Cloud Storage 버킷
  • DESTINATION_PATH: 대상 Cloud Storage 경로

전체 요청 예시

다음은 전체 요청의 예시입니다.

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "YOUR DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "schedule": {
      "scheduleStartDate": {
          "day": 1,
          "month": 1,
          "year": 2015
      },
      "startTimeOfDay": {
          "hours": 1,
          "minutes": 1
      }
  },
  "transferSpec": {
      "gcsDataSource": {
          "bucketName": "GCS_SOURCE_NAME",
          "path": "GCS_SOURCE_PATH",
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME",
          "path": "GCS_SINK_PATH",
      },
      "objectConditions": {
          "minTimeElapsedSinceLastModification": "2592000s"
      },
      "transferOptions": {
          "deleteObjectsFromSourceAfterTransfer": true
      }
  }

}

클라이언트 라이브러리

다음 샘플에서는 Go, 자바, Node.js, Python을 사용하여 프로그래매틱 방식으로 Storage Transfer Service를 사용하는 방법을 보여줍니다.

전송 작업을 프로그래매틱 방식으로 구성하거나 편집할 때 시간은 UTC여야 합니다. 전송 작업 일정을 지정하는 방법에 대한 자세한 내용은 일정을 참조하세요.

Storage Transfer Service 클라이언트 라이브러리에 대한 자세한 내용은 Storage Transfer Service 클라이언트 라이브러리 시작하기를 참조하세요.

Cloud Storage 버킷 간의 전송

이 예시에서는 하나의 Cloud Storage 버킷에서 다른 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다. 예를 들어 데이터를 다른 위치의 버킷으로 이동할 수 있습니다.

Go

import (
	"context"
	"fmt"
	"io"
	"time"

	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
	"google.golang.org/protobuf/types/known/durationpb"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferToNearline(w io.Writer, projectID string, gcsSourceBucket string, gcsNearlineSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID
	// projectID := "my-project-id"

	// The name of the GCS bucket to transfer objects from
	// gcsSourceBucket := "my-source-bucket"

	// The name of the Nearline GCS bucket to transfer objects to
	// gcsNearlineSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// A description of this job
	jobDescription := "Transfers objects that haven't been modified in 30 days to a Nearline bucket"

	// The time to start the transfer
	startTime := time.Now().UTC()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsNearlineSinkBucket}},
				DataSource: &storagetransferpb.TransferSpec_GcsDataSource{
					GcsDataSource: &storagetransferpb.GcsData{BucketName: gcsSourceBucket},
				},
				ObjectConditions: &storagetransferpb.ObjectConditions{
					MinTimeElapsedSinceLastModification: &durationpb.Duration{Seconds: 2592000 /*30 days */},
				},
				TransferOptions: &storagetransferpb.TransferOptions{DeleteObjectsFromSourceAfterTransfer: true},
			},
			Schedule: &storagetransferpb.Schedule{
				ScheduleStartDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				ScheduleEndDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				StartTimeOfDay: &timeofday.TimeOfDay{
					Hours:   int32(startTime.Hour()),
					Minutes: int32(startTime.Minute()),
					Seconds: int32(startTime.Second()),
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", gcsSourceBucket, gcsNearlineSinkBucket, resp.Name)
	return resp, nil
}

Java

이전 샘플을 찾고 계신가요? Storage Transfer Service 이전 가이드를 참조하세요.

import com.google.protobuf.Duration;
import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.ObjectConditions;
import com.google.storagetransfer.v1.proto.TransferTypes.Schedule;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferOptions;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferToNearline {
  /**
   * Creates a one-off transfer job that transfers objects in a standard GCS bucket that are more
   * than 30 days old to a Nearline GCS bucket.
   */
  public static void transferToNearline(
      String projectId,
      String jobDescription,
      String gcsSourceBucket,
      String gcsNearlineSinkBucket,
      long startDateTime)
      throws IOException {

    // Your Google Cloud Project ID
    // String projectId = "your-project-id";

    // A short description of this job
    // String jobDescription = "Sample transfer job of old objects to a Nearline GCS bucket.";

    // The name of the source GCS bucket to transfer data from
    // String gcsSourceBucket = "your-gcs-source-bucket";

    // The name of the Nearline GCS bucket to transfer old objects to
    // String gcsSinkBucket = "your-nearline-gcs-bucket";

    // What day and time in UTC to start the transfer, expressed as an epoch date timestamp.
    // If this is in the past relative to when the job is created, it will run the next day.
    // long startDateTime =
    //     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2000-01-01 00:00:00").getTime();

    // Parse epoch timestamp into the model classes
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTimeInMillis(startDateTime);
    // Note that this is a Date from the model class package, not a java.util.Date
    Date date =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay time =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setGcsDataSource(GcsData.newBuilder().setBucketName(gcsSourceBucket))
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsNearlineSinkBucket))
                    .setObjectConditions(
                        ObjectConditions.newBuilder()
                            .setMinTimeElapsedSinceLastModification(
                                Duration.newBuilder().setSeconds(2592000 /* 30 days */)))
                    .setTransferOptions(
                        TransferOptions.newBuilder().setDeleteObjectsFromSourceAfterTransfer(true)))
            .setSchedule(Schedule.newBuilder().setScheduleStartDate(date).setStartTimeOfDay(time))
            .setStatus(Status.ENABLED)
            .build();

    // Create a Transfer Service client
    StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create();

    // Create the transfer job
    TransferJob response =
        storageTransfer.createTransferJob(
            CreateTransferJobRequest.newBuilder().setTransferJob(transferJob).build());

    System.out.println("Created transfer job from standard bucket to Nearline bucket:");
    System.out.println(response.toString());
  }
}

Node.js


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// Google Cloud Storage source bucket name
// gcsSourceBucket = 'my-gcs-source-bucket'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Date to start daily migration
// startDate = new Date()

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Create a daily migration from a GCS bucket to another GCS bucket for
 * objects untouched for 30+ days.
 */
async function createDailyNearline30DayMigration() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: {
          day: startDate.getDate(),
          month: startDate.getMonth() + 1,
          year: startDate.getFullYear(),
        },
      },
      transferSpec: {
        gcsDataSource: {
          bucketName: gcsSourceBucket,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
        objectConditions: {
          minTimeElapsedSinceLastModification: {
            seconds: 2592000, // 30 days
          },
        },
        transferOptions: {
          deleteObjectsFromSourceAfterTransfer: true,
        },
      },
    },
  });

  console.log(`Created transferJob: ${transferJob.name}`);
}

createDailyNearline30DayMigration();

Python

이전 샘플을 찾고 계신가요? Storage Transfer Service 이전 가이드를 참조하세요.

from datetime import datetime

from google.cloud import storage_transfer
from google.protobuf.duration_pb2 import Duration

def create_daily_nearline_30_day_migration(
    project_id: str,
    description: str,
    source_bucket: str,
    sink_bucket: str,
    start_date: datetime,
):
    """Create a daily migration from a GCS bucket to a Nearline GCS bucket
    for objects untouched for 30 days."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # Google Cloud Storage source bucket name
    # source_bucket = 'my-gcs-source-bucket'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": {
                        "day": start_date.day,
                        "month": start_date.month,
                        "year": start_date.year,
                    }
                },
                "transfer_spec": {
                    "gcs_data_source": {
                        "bucket_name": source_bucket,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                    "object_conditions": {
                        "min_time_elapsed_since_last_modification": Duration(
                            seconds=2592000  # 30 days
                        )
                    },
                    "transfer_options": {
                        "delete_objects_from_source_after_transfer": True
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Amazon S3에서 Cloud Storage로 이전

이 예시에서는 파일을 Amazon S3에서 Cloud Storage 버킷으로 이동하는 방법을 학습합니다. 데이터를 Amazon S3에서 Cloud Storage로 이동할 때 발생하는 영향을 파악하려면 Amazon S3에 대한 액세스 구성가격 책정을 검토합니다.

전송 작업을 만들 때 Amazon S3 버킷 소스 이름에 bucketNames3:// 접두사를 포함하지 마세요.

Go

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
)

func transferFromAws(w io.Writer, projectID string, awsSourceBucket string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID
	// projectID := "my-project-id"

	// The name of the Aws bucket to transfer objects from
	// awsSourceBucket := "my-source-bucket"

	// The name of the GCS bucket to transfer objects to
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// A description of this job
	jobDescription := "Transfers objects from an AWS bucket to a GCS bucket"

	// The time to start the transfer
	startTime := time.Now().UTC()

	// The AWS access key credential, should be accessed via environment variable for security
	awsAccessKeyID := os.Getenv("AWS_ACCESS_KEY_ID")

	// The AWS secret key credential, should be accessed via environment variable for security
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AwsS3DataSource{
					AwsS3DataSource: &storagetransferpb.AwsS3Data{
						BucketName: awsSourceBucket,
						AwsAccessKey: &storagetransferpb.AwsAccessKey{
							AccessKeyId:     awsAccessKeyID,
							SecretAccessKey: awsSecretKey,
						}},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			Schedule: &storagetransferpb.Schedule{
				ScheduleStartDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				ScheduleEndDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				StartTimeOfDay: &timeofday.TimeOfDay{
					Hours:   int32(startTime.Hour()),
					Minutes: int32(startTime.Minute()),
					Seconds: int32(startTime.Second()),
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", awsSourceBucket, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

이전 샘플을 찾고 계신가요? Storage Transfer Service 이전 가이드를 참조하세요.


import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsAccessKey;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsS3Data;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.Schedule;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferFromAws {

  // Creates a one-off transfer job from Amazon S3 to Google Cloud Storage.
  public static void transferFromAws(
      String projectId,
      String jobDescription,
      String awsSourceBucket,
      String gcsSinkBucket,
      long startDateTime)
      throws IOException {

    // Your Google Cloud Project ID
    // String projectId = "your-project-id";

    // A short description of this job
    // String jobDescription = "Sample transfer job from S3 to GCS.";

    // The name of the source AWS bucket to transfer data from
    // String awsSourceBucket = "yourAwsSourceBucket";

    // The name of the GCS bucket to transfer data to
    // String gcsSinkBucket = "your-gcs-bucket";

    // What day and time in UTC to start the transfer, expressed as an epoch date timestamp.
    // If this is in the past relative to when the job is created, it will run the next day.
    // long startDateTime =
    //     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2000-01-01 00:00:00").getTime();

    // The ID used to access your AWS account. Should be accessed via environment variable.
    String awsAccessKeyId = System.getenv("AWS_ACCESS_KEY_ID");

    // The Secret Key used to access your AWS account. Should be accessed via environment variable.
    String awsSecretAccessKey = System.getenv("AWS_SECRET_ACCESS_KEY");

    // Set up source and sink
    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAwsS3DataSource(
                AwsS3Data.newBuilder()
                    .setBucketName(awsSourceBucket)
                    .setAwsAccessKey(
                        AwsAccessKey.newBuilder()
                            .setAccessKeyId(awsAccessKeyId)
                            .setSecretAccessKey(awsSecretAccessKey)))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket))
            .build();

    // Parse epoch timestamp into the model classes
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTimeInMillis(startDateTime);
    // Note that this is a Date from the model class package, not a java.util.Date
    Date startDate =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay startTime =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();
    Schedule schedule =
        Schedule.newBuilder()
            .setScheduleStartDate(startDate)
            .setScheduleEndDate(startDate)
            .setStartTimeOfDay(startTime)
            .build();

    // Set up the transfer job
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(transferSpec)
            .setSchedule(schedule)
            .setStatus(Status.ENABLED)
            .build();

    // Create a Transfer Service client
    StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create();

    // Create the transfer job
    TransferJob response =
        storageTransfer.createTransferJob(
            CreateTransferJobRequest.newBuilder().setTransferJob(transferJob).build());

    System.out.println("Created transfer job from AWS to GCS:");
    System.out.println(response.toString());
  }
}

Node.js


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// AWS S3 source bucket name
// awsSourceBucket = 'my-s3-source-bucket'

// AWS Access Key ID
// awsAccessKeyId = 'AKIA...'

// AWS Secret Access Key
// awsSecretAccessKey = 'HEAoMK2.../...ku8'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a one-time transfer job from Amazon S3 to Google Cloud Storage.
 */
async function transferFromS3() {
  // Setting the start date and the end date as the same time creates a
  // one-time transfer
  const now = new Date();
  const oneTimeSchedule = {
    day: now.getDate(),
    month: now.getMonth() + 1,
    year: now.getFullYear(),
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: oneTimeSchedule,
        scheduleEndDate: oneTimeSchedule,
      },
      transferSpec: {
        awsS3DataSource: {
          bucketName: awsSourceBucket,
          awsAccessKey: {
            accessKeyId: awsAccessKeyId,
            secretAccessKey: awsSecretAccessKey,
          },
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

  console.log(
    `Created and ran a transfer job from '${awsSourceBucket}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferFromS3();

Python

이전 샘플을 찾고 계신가요? Storage Transfer Service 이전 가이드를 참조하세요.

from datetime import datetime

from google.cloud import storage_transfer

def create_one_time_aws_transfer(
    project_id: str,
    description: str,
    source_bucket: str,
    aws_access_key_id: str,
    aws_secret_access_key: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Amazon S3 to Google Cloud
    Storage."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # AWS S3 source bucket name
    # source_bucket = 'my-s3-source-bucket'

    # AWS Access Key ID
    # aws_access_key_id = 'AKIA...'

    # AWS Secret Access Key
    # aws_secret_access_key = 'HEAoMK2.../...ku8'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    now = datetime.utcnow()
    # Setting the start date and the end date as
    # the same time creates a one-time transfer
    one_time_schedule = {"day": now.day, "month": now.month, "year": now.year}

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": one_time_schedule,
                    "schedule_end_date": one_time_schedule,
                },
                "transfer_spec": {
                    "aws_s3_data_source": {
                        "bucket_name": source_bucket,
                        "aws_access_key": {
                            "access_key_id": aws_access_key_id,
                            "secret_access_key": aws_secret_access_key,
                        },
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

Microsoft Azure Blob Storage와 Cloud Storage 간 전송

이 예시에서는 Microsoft Azure Storage 공유 액세스 서명(SAS) 토큰을 사용하여 Microsoft Azure Storage에서 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다.

Microsoft Azure Storage SAS에 대한 자세한 내용은 공유 액세스 서명(SAS)을 사용하여 Azure Storage 리소스에 대한 제한된 액세스 권한 부여를 참조하세요.

시작하기 전에 Microsoft Azure Storage 액세스 구성가격 책정을 검토하여 Microsoft Azure Storage에서 Cloud Storage로 데이터를 이동할 때 발생하는 영향을 알아봅니다.

Go

Storage Transfer Service용 클라이언트 라이브러리를 설치하고 사용하는 방법은 Storage Transfer Service 클라이언트 라이브러리를 참조하세요. 자세한 내용은 Storage Transfer Service Go API 참조 문서를 참조하세요.

Storage Transfer Service에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

import (
	"context"
	"fmt"
	"io"
	"os"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromAzure(w io.Writer, projectID string, azureStorageAccountName string, azureSourceContainer string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID.
	// projectID := "my-project-id"

	// The name of your Azure Storage account.
	// azureStorageAccountName := "my-azure-storage-acc"

	// The name of the Azure container to transfer objects from.
	// azureSourceContainer := "my-source-container"

	// The name of the GCS bucket to transfer objects to.
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// The Azure SAS token, should be accessed via environment variable for security
	azureSasToken := os.Getenv("AZURE_SAS_TOKEN")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AzureBlobStorageDataSource{
					AzureBlobStorageDataSource: &storagetransferpb.AzureBlobStorageData{
						StorageAccount: azureStorageAccountName,
						AzureCredentials: &storagetransferpb.AzureCredentials{
							SasToken: azureSasToken,
						},
						Container: azureSourceContainer,
					},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", azureSourceContainer, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

Storage Transfer Service용 클라이언트 라이브러리를 설치하고 사용하는 방법은 Storage Transfer Service 클라이언트 라이브러리를 참조하세요. 자세한 내용은 Storage Transfer Service Java API 참조 문서를 참조하세요.

Storage Transfer Service에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferProto.RunTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureBlobStorageData;
import com.google.storagetransfer.v1.proto.TransferTypes.AzureCredentials;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class TransferFromAzure {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    // Your Google Cloud Project ID
    String projectId = "my-project-id";

    // Your Azure Storage Account name
    String azureStorageAccount = "my-azure-account";

    // The Azure source container to transfer data from
    String azureSourceContainer = "my-source-container";

    // The GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    transferFromAzureBlobStorage(
        projectId, azureStorageAccount, azureSourceContainer, gcsSinkBucket);
  }

  /**
   * Creates and runs a transfer job to transfer all data from an Azure container to a GCS bucket.
   */
  public static void transferFromAzureBlobStorage(
      String projectId,
      String azureStorageAccount,
      String azureSourceContainer,
      String gcsSinkBucket)
      throws IOException, ExecutionException, InterruptedException {

    // Your Azure SAS token, should be accessed via environment variable
    String azureSasToken = System.getenv("AZURE_SAS_TOKEN");

    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAzureBlobStorageDataSource(
                AzureBlobStorageData.newBuilder()
                    .setAzureCredentials(
                        AzureCredentials.newBuilder().setSasToken(azureSasToken).build())
                    .setContainer(azureSourceContainer)
                    .setStorageAccount(azureStorageAccount))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket).build())
            .build();

    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setStatus(Status.ENABLED)
            .setTransferSpec(transferSpec)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {
      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      // Run the created job
      storageTransfer
          .runTransferJobAsync(
              RunTransferJobRequest.newBuilder()
                  .setProjectId(projectId)
                  .setJobName(response.getName())
                  .build())
          .get();

      System.out.println(
          "Created and ran a transfer job from "
              + azureSourceContainer
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js

Storage Transfer Service용 클라이언트 라이브러리를 설치하고 사용하는 방법은 Storage Transfer Service 클라이언트 라이브러리를 참조하세요. 자세한 내용은 Storage Transfer Service Node.js API 참조 문서를 참조하세요.

Storage Transfer Service에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// Azure Storage Account name
// azureStorageAccount = 'accountname'

// Azure Storage Account name
// azureSourceContainer = 'my-azure-source-bucket'

// Azure Shared Access Signature token
// azureSASToken = '?sv=...'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a one-time transfer job from Azure Blob Storage to Google Cloud Storage.
 */
async function transferFromBlobStorage() {
  // Setting the start date and the end date as the same time creates a
  // one-time transfer
  const now = new Date();
  const oneTimeSchedule = {
    day: now.getDate(),
    month: now.getMonth() + 1,
    year: now.getFullYear(),
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: oneTimeSchedule,
        scheduleEndDate: oneTimeSchedule,
      },
      transferSpec: {
        azureBlobStorageDataSource: {
          azureCredentials: {
            sasToken: azureSASToken,
          },
          container: azureSourceContainer,
          storageAccount: azureStorageAccount,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

  console.log(
    `Created and ran a transfer job from '${azureSourceContainer}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferFromBlobStorage();

Python

Storage Transfer Service용 클라이언트 라이브러리를 설치하고 사용하는 방법은 Storage Transfer Service 클라이언트 라이브러리를 참조하세요. 자세한 내용은 Storage Transfer Service Python API 참조 문서를 참조하세요.

Storage Transfer Service에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

from datetime import datetime

from google.cloud import storage_transfer

def create_one_time_azure_transfer(
    project_id: str,
    description: str,
    azure_storage_account: str,
    azure_sas_token: str,
    source_container: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Azure Blob Storage to Google Cloud
    Storage."""

    # Initialize client that will be used to create storage transfer requests.
    # This client only needs to be created once, and can be reused for
    # multiple requests.
    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # Azure Storage Account name
    # azure_storage_account = 'accountname'

    # Azure Shared Access Signature token
    # azure_sas_token = '?sv=...'

    # Azure Blob source container name
    # source_container = 'my-azure-source-bucket'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    now = datetime.utcnow()
    # Setting the start date and the end date as
    # the same time creates a one-time transfer
    one_time_schedule = {"day": now.day, "month": now.month, "year": now.year}

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": one_time_schedule,
                    "schedule_end_date": one_time_schedule,
                },
                "transfer_spec": {
                    "azure_blob_storage_data_source": {
                        "storage_account": azure_storage_account,
                        "azure_credentials": {"sas_token": azure_sas_token},
                        "container": source_container,
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")

파일 시스템에서 전송

이 예시에서는 POSIX 파일 시스템에서 Cloud Storage 버킷으로 파일을 이동하는 방법을 알아봅니다.

Go


import (
	"context"
	"fmt"
	"io"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromPosix(w io.Writer, projectID string, sourceAgentPoolName string, rootDirectory string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your project id
	// projectId := "myproject-id"

	// The agent pool associated with the POSIX data source. If not provided, defaults to the default agent
	// sourceAgentPoolName := "projects/my-project/agentPools/transfer_service_default"

	// The root directory path on the source filesystem
	// rootDirectory := "/directory/to/transfer/source"

	// The ID of the GCS bucket to transfer data to
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				SourceAgentPoolName: sourceAgentPoolName,
				DataSource: &storagetransferpb.TransferSpec_PosixDataSource{
					PosixDataSource: &storagetransferpb.PosixFilesystem{RootDirectory: rootDirectory},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket},
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}

	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", rootDirectory, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.PosixFilesystem;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferFromPosix {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Your project id
    String projectId = "my-project-id";

    // The agent pool associated with the POSIX data source. If not provided, defaults to the
    // default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The root directory path on the source filesystem
    String rootDirectory = "/directory/to/transfer/source";

    // The ID of the GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    transferFromPosix(projectId, sourceAgentPoolName, rootDirectory, gcsSinkBucket);
  }

  public static void transferFromPosix(
      String projectId, String sourceAgentPoolName, String rootDirectory, String gcsSinkBucket)
      throws IOException {
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setPosixDataSource(
                        PosixFilesystem.newBuilder().setRootDirectory(rootDirectory).build())
                    .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket).build()))
            .setStatus(TransferJob.Status.ENABLED)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {

      // Create the transfer job
      TransferJob response =
          storageTransfer.createTransferJob(
              TransferProto.CreateTransferJobRequest.newBuilder()
                  .setTransferJob(transferJob)
                  .build());

      System.out.println(
          "Created a transfer job from "
              + rootDirectory
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js


// Imports the Google Cloud client library
const {
  StorageTransferServiceClient,
} = require('@google-cloud/storage-transfer');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Your project id
// const projectId = 'my-project'

// The agent pool associated with the POSIX data source. Defaults to the default agent
// const sourceAgentPoolName = 'projects/my-project/agentPools/transfer_service_default'

// The root directory path on the source filesystem
// const rootDirectory = '/directory/to/transfer/source'

// The ID of the GCS bucket to transfer data to
// const gcsSinkBucket = 'my-sink-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a request to transfer from the local file system to the sink bucket
 */
async function transferDirectory() {
  const createRequest = {
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        posixDataSource: {
          rootDirectory,
        },
        gcsDataSink: {bucketName: gcsSinkBucket},
      },
      status: 'ENABLED',
    },
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob(createRequest);

  const runRequest = {
    jobName: transferJob.name,
    projectId: projectId,
  };

  await client.runTransferJob(runRequest);

  console.log(
    `Created and ran a transfer job from '${rootDirectory}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferDirectory();

Python

from google.cloud import storage_transfer

def transfer_from_posix_to_gcs(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    root_directory: str,
    sink_bucket: str,
):
    """Create a transfer from a POSIX file system to a GCS bucket."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # The agent pool associated with the POSIX data source.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # source_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The root directory path on the source filesystem
    # root_directory = '/directory/to/transfer/source'

    # Google Cloud Storage sink bucket name
    # sink_bucket = 'my-gcs-sink-bucket'

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "source_agent_pool_name": source_agent_pool_name,
                    "posix_data_source": {
                        "root_directory": root_directory,
                    },
                    "gcs_data_sink": {"bucket_name": sink_bucket},
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")