기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# 스토리지 볼륨의 스냅샷 삭제
<a name="DeletingASnapshot"></a>

스토리지 볼륨의 스냅샷을 삭제할 수 있습니다. 예를 들어, 시간이 지남에 따라 많은 수의 스토리지 볼륨 스냅샷이 생성되어 이전 스냅샷이 필요 없는 경우 삭제하려고 할 수 있습니다. 스냅샷은 증분식 백업이기 때문에 스냅샷을 삭제하면 다른 스냅샷에 필요하지 않은 데이터만 삭제됩니다.

**Topics**
+ [Java용 AWS SDK를 사용하여 스냅샷 삭제](#DeletingSnapshotsUsingJava)
+ [.NET용 AWS SDK를 사용하여 스냅샷 삭제](#DeletingSnapshotsUsingDotNet)
+ [를 사용하여 스냅샷 삭제 AWS Tools for Windows PowerShell](#DeletingSnapshotsUsingPowerShell)

Amazon EBS 콘솔에서 스냅샷을 한 번에 하나씩 삭제할 수 있습니다. Amazon EBS 콘솔을 사용하여 스냅샷을 삭제하는 방법에 대한 자세한 내용은 Amazon EC2 사용 설명서에서 [Amazon EBS 스냅샷 삭제](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-snapshot.html)를 참조하세요.**

 한 번에 여러 스냅샷을 삭제하려면 Storage Gateway 작업을 지원하는 AWS SDKs 중 하나를 사용할 수 있습니다. 예시는 [Java용 AWS SDK를 사용하여 스냅샷 삭제](#DeletingSnapshotsUsingJava), [.NET용 AWS SDK를 사용하여 스냅샷 삭제](#DeletingSnapshotsUsingDotNet) 및 [를 사용하여 스냅샷 삭제 AWS Tools for Windows PowerShell](#DeletingSnapshotsUsingPowerShell) 단원을 참조하십시오.

## Java용 AWS SDK를 사용하여 스냅샷 삭제
<a name="DeletingSnapshotsUsingJava"></a>

볼륨과 연결된 여러 스냅샷을 삭제할 때는 프로그래밍 접근 방식을 사용할 수 있습니다. 다음 예시는 Java용 AWS SDK를 사용하여 스냅샷을 삭제하는 방법을 보여줍니다. 예시 코드를 사용하려면 Java 콘솔 애플리케이션을 실행하는 방법을 잘 알아야 합니다. 자세한 내용은 Java용AWS SDK 개발자 안내서에서 [시작하기](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/java-dg-setup.html)를 참조하세요.** 스냅샷을 몇 개만 삭제하는 경우, [스토리지 볼륨의 스냅샷 삭제](#DeletingASnapshot) 단원의 설명 대로 콘솔을 사용하여 삭제합니다.

**Example : Java용 AWS SDK를 사용하여 스냅샷 삭제**  
다음 Java 코드 예시에는 게이트웨이의 각 볼륨에 대한 스냅샷과 함께 스냅샷 시작 시각이 지정한 날짜 이전인지 이후인지 여부가 나열되어 있습니다. Storage Gateway 및 Amazon EC2용 Java용 AWS SDK API를 사용합니다. Amazon EC2 API에는 스냅샷 처리를 위한 작업이 포함되어 있습니다.  
서비스 엔드포인트, 게이트웨이 Amazon 리소스 이름(ARN) 및 스냅샷을 저장하려는 이전 일수를 제공하도록 코드를 업데이트합니다. 이 기간 이전에 생성된 스냅샷은 삭제됩니다. 또한 부울 값 `viewOnly`를 지정해야 합니다. 이 값은 삭제할 스냅샷을 보길 원하는지, 아니면 스냅샷 삭제를 실제로 수행하길 원하는지 알려줍니다. 코드가 삭제하는 항목을 확인하려면 보기 옵션만 사용하여(즉, `viewOnly`가 `true`로 설정됨) 먼저 코드를 실행합니다. Storage Gateway에서 사용할 수 있는 AWS 서비스 엔드포인트 목록은의 [AWS Storage Gateway 엔드포인트 및 할당량을 참조하세요](https://docs.aws.amazon.com/general/latest/gr/sg.html)*AWS 일반 참조*.  

```
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import com.amazonaws.auth.PropertiesCredentials;
import com.amazonaws.services.ec2.AmazonEC2Client;
import com.amazonaws.services.ec2.model.DeleteSnapshotRequest;
import com.amazonaws.services.ec2.model.DescribeSnapshotsRequest;
import com.amazonaws.services.ec2.model.DescribeSnapshotsResult;
import com.amazonaws.services.ec2.model.Filter;
import com.amazonaws.services.ec2.model.Snapshot;
import com.amazonaws.services.storagegateway.AWSStorageGatewayClient;
import com.amazonaws.services.storagegateway.model.ListVolumesRequest;
import com.amazonaws.services.storagegateway.model.ListVolumesResult;
import com.amazonaws.services.storagegateway.model.VolumeInfo;

public class ListDeleteVolumeSnapshotsExample {

    public static AWSStorageGatewayClient sgClient;
    public static AmazonEC2Client ec2Client;    
    static String serviceURLSG = "https://storagegateway.us-east-1.amazonaws.com";
    static String serviceURLEC2 = "https://ec2.us-east-1.amazonaws.com"; 
    
    // The gatewayARN
    public static String gatewayARN = "*** provide gateway ARN ***";
    
    // The number of days back you want to save snapshots. Snapshots before this cutoff are deleted
    // if viewOnly = false.
    public static int daysBack = 10;
    
    // true = show what will be deleted; false = actually delete snapshots that meet the daysBack criteria
    public static boolean viewOnly = true;

    public static void main(String[] args) throws IOException {

        // Create a Storage Gateway and amazon ec2 client
        sgClient = new AWSStorageGatewayClient(new PropertiesCredentials(
                ListDeleteVolumeSnapshotsExample.class.getResourceAsStream("AwsCredentials.properties")));    
        sgClient.setEndpoint(serviceURLSG);
        
        ec2Client = new AmazonEC2Client(new PropertiesCredentials(
                ListDeleteVolumeSnapshotsExample.class.getResourceAsStream("AwsCredentials.properties")));
        ec2Client.setEndpoint(serviceURLEC2);        
        
        List<VolumeInfo> volumes = ListVolumesForGateway();
        DeleteSnapshotsForVolumes(volumes, daysBack);        
        
    }
    public static List<VolumeInfo> ListVolumesForGateway()
    {
        List<VolumeInfo> volumes = new ArrayList<VolumeInfo>();

        String marker = null;
        do {
            ListVolumesRequest request = new ListVolumesRequest().withGatewayARN(gatewayARN);
            ListVolumesResult result = sgClient.listVolumes(request);
            marker = result.getMarker();
            
            for (VolumeInfo vi : result.getVolumeInfos())
            {
                volumes.add(vi);
                System.out.println(OutputVolumeInfo(vi));
            }           
        } while (marker != null);

        return volumes;
    }
    private static void DeleteSnapshotsForVolumes(List<VolumeInfo> volumes,
            int daysBack2) {
        
        // Find snapshots and delete for each volume 
        for (VolumeInfo vi : volumes) {
            
            String volumeARN = vi.getVolumeARN();
            String volumeId = volumeARN.substring(volumeARN.lastIndexOf("/")+1).toLowerCase();
            Collection<Filter> filters = new ArrayList<Filter>();
            Filter filter = new Filter().withName("volume-id").withValues(volumeId);
            filters.add(filter);
            
            DescribeSnapshotsRequest describeSnapshotsRequest =
                new DescribeSnapshotsRequest().withFilters(filters);
            DescribeSnapshotsResult describeSnapshotsResult =
                ec2Client.describeSnapshots(describeSnapshotsRequest);
            
            List<Snapshot> snapshots = describeSnapshotsResult.getSnapshots();
            System.out.println("volume-id = " + volumeId);
            for (Snapshot s : snapshots){
                StringBuilder sb = new StringBuilder();
                boolean meetsCriteria = !CompareDates(daysBack, s.getStartTime());
                sb.append(s.getSnapshotId() + ", " + s.getStartTime().toString());                
                sb.append(", meets criteria for delete? " + meetsCriteria);
                sb.append(", deleted? ");
                if (!viewOnly & meetsCriteria) {
                    sb.append("yes");
                    DeleteSnapshotRequest deleteSnapshotRequest = 
                        new DeleteSnapshotRequest().withSnapshotId(s.getSnapshotId());
                    ec2Client.deleteSnapshot(deleteSnapshotRequest);
                }
                else {
                    sb.append("no");
                }
                System.out.println(sb.toString());                    
            }        
        }
    }

    private static String OutputVolumeInfo(VolumeInfo vi) {
        
        String volumeInfo = String.format(
                 "Volume Info:\n" + 
                 "  ARN: %s\n" +
                 "  Type: %s\n",
                 vi.getVolumeARN(),
                 vi.getVolumeType());
        return volumeInfo; 
     }
    
    // Returns the date in two formats as a list
    public static boolean CompareDates(int daysBack, Date snapshotDate) {
        Date today = new Date();
        Calendar cal = new GregorianCalendar();
        cal.setTime(today);
        cal.add(Calendar.DAY_OF_MONTH, -daysBack);
        Date cutoffDate = cal.getTime();        
        return (snapshotDate.compareTo(cutoffDate) > 0) ? true : false;
    }

}
```

## .NET용 AWS SDK를 사용하여 스냅샷 삭제
<a name="DeletingSnapshotsUsingDotNet"></a>

볼륨과 연결된 여러 스냅샷을 삭제할 때는 프로그래밍 접근 방식을 사용할 수 있습니다. 다음 예시는 .NET용 AWS SDK 버전 2 및 3을 사용하여 스냅샷을 삭제하는 방법을 보여줍니다. 예시 코드를 사용하려면 .NET 콘솔 애플리케이션을 실행하는 방법을 잘 알아야 합니다. 자세한 내용은 .NET용AWS SDK 개발자 안내서에서 [시작하기](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-config.html)를 참조하세요.** 스냅샷을 몇 개만 삭제하는 경우, [스토리지 볼륨의 스냅샷 삭제](#DeletingASnapshot) 단원의 설명 대로 콘솔을 사용하여 삭제합니다.

**Example : .NET용 AWS SDK를 사용하여 스냅샷 삭제**  
다음 C\$1 코드 예제에서 AWS Identity and Access Management 사용자는 게이트웨이의 각 볼륨에 대한 스냅샷을 나열할 수 있습니다. 그런 다음 스냅샷 시작 시간이 지정된 날짜(보존 기간) 이전 또는 이후인지 확인하고 보존 기간이 지난 스냅샷을 삭제합니다. 이 예제에서는 Storage Gateway 및 Amazon EC2용 AWS SDK for .NET API를 사용합니다. Amazon EC2 API에는 스냅샷 처리를 위한 작업이 포함되어 있습니다.  
다음 코드 예제에서는 AWS SDK for .NET 버전 2 및 3을 사용합니다. .NET의 이전 버전을 새 버전으로 마이그레이션할 수 있습니다. 자세한 내용은 [.NET용 AWS SDK의 프로젝트 마이그레이션을 참조하세요](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-migrating.html).  
서비스 엔드포인트, 게이트웨이 Amazon 리소스 이름(ARN) 및 스냅샷을 저장하려는 이전 일수를 제공하도록 코드를 업데이트합니다. 이 기간 이전에 생성된 스냅샷은 삭제됩니다. 또한 부울 값 `viewOnly`를 지정해야 합니다. 이 값은 삭제할 스냅샷을 보길 원하는지, 아니면 스냅샷 삭제를 실제로 수행하길 원하는지 알려줍니다. 코드가 삭제하는 항목을 확인하려면 보기 옵션만 사용하여(즉, `viewOnly`가 `true`로 설정됨) 먼저 코드를 실행합니다. Storage Gateway와 함께 사용할 수 있는 AWS 서비스 엔드포인트 목록은의 [AWS Storage Gateway 엔드포인트 및 할당량을 참조하세요](https://docs.aws.amazon.com/general/latest/gr/sg.html)*AWS 일반 참조*.  
 먼저 IAM 사용자를 생성하고 이 사용자에게 최소 IAM 정책을 연결합니다. 그 다음에 게이트웨이에 대한 자동 스냅샷을 예약합니다.  
다음 코드에서는 사용자가 스냅샷을 삭제하도록 허용하는 최소 정책을 생성합니다. 이 예제에서 정책 이름은 **sgw-delete-snapshot**입니다.    
****  

```
{
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "StmtEC2Snapshots",
              "Effect": "Allow",
              "Action": [
                  "ec2:DeleteSnapshot",
                  "ec2:DescribeSnapshots"
              ],
              "Resource": [
                  "*"
              ]
          },
          {
              "Sid": "StmtSgwListVolumes",
              "Effect": "Allow",
              "Action": [
                  "storagegateway:ListVolumes"
              ],
              "Resource": [
                  "*"
              ]
          }
      ]
  }
```
다음 C\$1 코드는 지정된 게이트웨이에서 볼륨과 지정된 기간과 일치하는 스냅샷을 모두 찾아 삭제합니다.  

```
using System;
using System.Collections.Generic;
using System.Text;
using Amazon.EC2;
using Amazon.EC2.Model;
using Amazon.StorageGateway.Model;
using Amazon.StorageGateway;

namespace DeleteStorageGatewaySnapshotNS
{
    class Program
    {
        /*
         * Replace the variables below to match your environment.
         */
         
         /* IAM AccessKey */
        static String AwsAccessKey = "AKIA................";
        
        /* IAM SecretKey */
        static String AwsSecretKey = "*******************************";
        
        /* Account number, 12 digits, no hyphen */
        static String OwnerID = "123456789012";
        
        /* Your Gateway ARN. Use a Storage Gateway ID, sgw-XXXXXXXX* */ 
        static String GatewayARN = "arn:aws:storagegateway:ap-southeast-2:123456789012:gateway/sgw-XXXXXXXX";
        
        /* Snapshot status: "completed", "pending", "error" */                                                                                                      
        static String SnapshotStatus = "completed";
        
        /* Region where your gateway is activated */ 
        static String AwsRegion = "ap-southeast-2";
        
        /* Minimum age of snapshots before they are deleted (retention policy) */
        static int daysBack = 30; 

        /*
         * Do not modify the four lines below.
         */
        static AmazonEC2Config ec2Config;
        static AmazonEC2Client ec2Client;
        static AmazonStorageGatewayClient sgClient;
        static AmazonStorageGatewayConfig sgConfig;

        static void Main(string[] args)
        {
            // Create an EC2 client.
            ec2Config = new AmazonEC2Config();
            ec2Config.ServiceURL = "https://ec2." + AwsRegion + ".amazonaws.com";
            ec2Client = new AmazonEC2Client(AwsAccessKey, AwsSecretKey, ec2Config);

            // Create a Storage Gateway client.
            sgConfig = new AmazonStorageGatewayConfig();
            sgConfig.ServiceURL = "https://storagegateway." + AwsRegion + ".amazonaws.com";
            sgClient = new AmazonStorageGatewayClient(AwsAccessKey, AwsSecretKey, sgConfig);

            List<VolumeInfo> StorageGatewayVolumes = ListVolumesForGateway();
            List<Snapshot> StorageGatewaySnapshots = ListSnapshotsForVolumes(StorageGatewayVolumes, 
                                                     daysBack);
            DeleteSnapshots(StorageGatewaySnapshots);
        }

        /*
         * List all volumes for your gateway
         * returns: A list of VolumeInfos, or null.
         */
        private static List<VolumeInfo> ListVolumesForGateway()
        {
            ListVolumesResponse response = new ListVolumesResponse();
            try
            {
                ListVolumesRequest request = new ListVolumesRequest();
                request.GatewayARN = GatewayARN;
                response = sgClient.ListVolumes(request);

                foreach (VolumeInfo vi in response.VolumeInfos)
                {
                    Console.WriteLine(OutputVolumeInfo(vi));
                }
            }
            catch (AmazonStorageGatewayException ex)
            {
                Console.WriteLine(ex.Message);
            }
            return response.VolumeInfos;
        }

        /*
         * Gets the list of snapshots that match the requested volumes
         * and cutoff period.
         */
        private static List<Snapshot> ListSnapshotsForVolumes(List<VolumeInfo> volumes, int snapshotAge)
        {
            List<Snapshot> SelectedSnapshots = new List<Snapshot>();
            try
            {
                foreach (VolumeInfo vi in volumes)
                {
                    String volumeARN = vi.VolumeARN;
                    String volumeID = volumeARN.Substring(volumeARN.LastIndexOf("/") + 1).ToLower();

                    DescribeSnapshotsRequest describeSnapshotsRequest = new DescribeSnapshotsRequest();

                    Filter ownerFilter = new Filter();
                    List<String> ownerValues = new List<String>();
                    ownerValues.Add(OwnerID);
                    ownerFilter.Name = "owner-id";
                    ownerFilter.Values = ownerValues;
                    describeSnapshotsRequest.Filters.Add(ownerFilter);

                    Filter statusFilter = new Filter();
                    List<String> statusValues = new List<String>();
                    statusValues.Add(SnapshotStatus);
                    statusFilter.Name = "status";
                    statusFilter.Values = statusValues;
                    describeSnapshotsRequest.Filters.Add(statusFilter);

                    Filter volumeFilter = new Filter();
                    List<String> volumeValues = new List<String>();
                    volumeValues.Add(volumeID);
                    volumeFilter.Name = "volume-id";
                    volumeFilter.Values = volumeValues;
                    describeSnapshotsRequest.Filters.Add(volumeFilter);

                    DescribeSnapshotsResponse describeSnapshotsResponse = 
                      ec2Client.DescribeSnapshots(describeSnapshotsRequest);

                    List<Snapshot> snapshots = describeSnapshotsResponse.Snapshots;
                    Console.WriteLine("volume-id = " + volumeID);
                    foreach (Snapshot s in snapshots)
                    {
                        if (IsSnapshotPastRetentionPeriod(snapshotAge, s.StartTime))
                        {
                            Console.WriteLine(s.SnapshotId + ", " + s.VolumeId + ", 
                               " + s.StartTime + ", " + s.Description);
                            SelectedSnapshots.Add(s);
                        }
                    }
                }
            }
            catch (AmazonEC2Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return SelectedSnapshots;
        }

        /*
         * Deletes a list of snapshots.
         */
        private static void DeleteSnapshots(List<Snapshot> snapshots)
        {
            try
            {
                foreach (Snapshot s in snapshots)
                {

                    DeleteSnapshotRequest deleteSnapshotRequest = new DeleteSnapshotRequest(s.SnapshotId);
                    DeleteSnapshotResponse response = ec2Client.DeleteSnapshot(deleteSnapshotRequest);
                    Console.WriteLine("Volume: " +
                              s.VolumeId +
                              " => Snapshot: " +
                              s.SnapshotId +
                              " Response: "
                              + response.HttpStatusCode.ToString());
                }
            }
            catch (AmazonEC2Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        /*
         * Checks if the snapshot creation date is past the retention period.
         */
        private static Boolean IsSnapshotPastRetentionPeriod(int daysBack, DateTime snapshotDate)
        {
            DateTime cutoffDate = DateTime.Now.Add(new TimeSpan(-daysBack, 0, 0, 0));
            return (DateTime.Compare(snapshotDate, cutoffDate) < 0) ? true : false;
        }

        /*
         * Displays information related to a volume.
         */
        private static String OutputVolumeInfo(VolumeInfo vi)
        {
            String volumeInfo = String.Format(
                "Volume Info:\n" +
                "  ARN: {0}\n" +
                "  Type: {1}\n",
                vi.VolumeARN,
                vi.VolumeType);
            return volumeInfo;
        }
    }
}
```

## 를 사용하여 스냅샷 삭제 AWS Tools for Windows PowerShell
<a name="DeletingSnapshotsUsingPowerShell"></a>

볼륨과 연결된 여러 스냅샷을 삭제할 때는 프로그래밍 접근 방식을 사용할 수 있습니다. 다음 예시는 AWS Tools for Windows PowerShell를 사용하여 스냅샷을 삭제하는 방법을 보여줍니다. 예시 스크립트를 사용하려면 PowerShell 스크립트를 실행하는 방법을 잘 알아야 합니다. 자세한 내용은 [시작하기](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-started.html)(출처: *AWS Tools for Windows PowerShell*)를 참조하십시오. 스냅샷을 몇 개만 삭제하는 경우, [스토리지 볼륨의 스냅샷 삭제](#DeletingASnapshot) 단원의 설명 대로 콘솔을 사용하여 삭제합니다.

**Example :를 사용하여 스냅샷 삭제 AWS Tools for Windows PowerShell**  
다음 PowerShell 스크립트 예시에는 게이트웨이의 각 볼륨에 대한 스냅샷과 함께 스냅샷 시작 시각이 지정한 날짜 이전인지 이후인지 여부가 나열되어 있습니다. Storage Gateway 및 Amazon EC2에 AWS Tools for Windows PowerShell cmdlet을 사용합니다. Amazon EC2 API에는 스냅샷 처리를 위한 작업이 포함되어 있습니다.  
스크립트를 업데이트해 게이트웨이 Amazon 리소스 이름(ARN) 및 스냅샷을 저장하려는 이전 일수를 제공해야 합니다. 이 기간 이전에 생성된 스냅샷은 삭제됩니다. 또한 부울 값 `viewOnly`를 지정해야 합니다. 이 값은 삭제할 스냅샷을 보길 원하는지, 아니면 스냅샷 삭제를 실제로 수행하길 원하는지 알려줍니다. 코드가 삭제하는 항목을 확인하려면 보기 옵션만 사용하여(즉, `viewOnly`가 `true`로 설정됨) 먼저 코드를 실행합니다.  

```
<#
.DESCRIPTION
    Delete snapshots of a specified volume that match given criteria.
    
.NOTES
    PREREQUISITES:
    1) AWS Tools for Windows PowerShell from https://aws.amazon.com/powershell/
    2) Credentials and AWS Region stored in session using Initialize-AWSDefault.
    For more info see, https://docs.aws.amazon.com/powershell/latest/userguide/specifying-your-aws-credentials.html 

.EXAMPLE
    powershell.exe .\SG_DeleteSnapshots.ps1  
#>

# Criteria to use to filter the results returned.
$daysBack = 18
$gatewayARN = "*** provide gateway ARN ***"
$viewOnly = $true;

#ListVolumes
$volumesResult = Get-SGVolume -GatewayARN $gatewayARN
$volumes = $volumesResult.VolumeInfos
Write-Output("`nVolume List")
foreach ($volumes in $volumesResult)
  { Write-Output("`nVolume Info:")
    Write-Output("ARN:  " + $volumes.VolumeARN)
    write-Output("Type: " + $volumes.VolumeType)
  }

Write-Output("`nWhich snapshots meet the criteria?")
foreach ($volume in $volumesResult)
  { 
    $volumeARN = $volume.VolumeARN
    
    $volumeId = ($volumeARN-split"/")[3].ToLower()
  
    $filter = New-Object Amazon.EC2.Model.Filter
    $filter.Name = "volume-id"
    $filter.Value.Add($volumeId)
    
    $snapshots = get-EC2Snapshot -Filter $filter    
    Write-Output("`nFor volume-id = " + $volumeId)
    foreach ($s in $snapshots)
    {
       $d = ([DateTime]::Now).AddDays(-$daysBack)
       $meetsCriteria = $false
       if ([DateTime]::Compare($d, $s.StartTime) -gt 0)
       {
            $meetsCriteria = $true
       }
       
       $sb = $s.SnapshotId + ", " + $s.StartTime + ", meets criteria for delete? " + $meetsCriteria
       if (!$viewOnly -AND $meetsCriteria) 
       {
           $resp = Remove-EC2Snapshot -SnapshotId $s.SnapshotId
           #Can get RequestId from response for troubleshooting.
           $sb = $sb + ", deleted? yes"
       }
       else {
           $sb = $sb + ", deleted? no"
       }
       Write-Output($sb) 
    }
  }
```