

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 在 CodeArtifact 中使用套件
<a name="packages"></a>

下列主題說明如何使用 CodeArtifact CLI 和 API 對套件執行動作。

**Topics**
+ [套件概觀](packages-overview.md)
+ [列出套件名稱](list-packages.md)
+ [列出套件版本](list-packages-versions.md)
+ [列出套件版本資產](list-assets.md)
+ [下載套件版本資產](download-assets.md)
+ [在儲存庫之間複製套件](copy-package.md)
+ [刪除套件或套件版本](delete-package.md)
+ [檢視和更新套件版本詳細資訊和相依性](describe-package-version.md)
+ [更新套件版本狀態](update-package-version-status.md)
+ [編輯套件原始伺服器控制項](package-origin-controls.md)

# 套件概觀
<a name="packages-overview"></a>

*套件*是軟體和中繼資料的套件，用於解析相依性和安裝軟體。在 CodeArtifact 中，套件包含套件名稱、選用[的命名空間](codeartifact-concepts.md#welcome-concepts-package-namespace)，例如 `@types`中的 `@types/node`、一組套件版本，以及套件層級中繼資料，例如 npm 標籤。

**Contents**
+ [支援的套件格式](#supported-package-formats)
+ [套件發佈](#package-publishing)
  + [發佈許可](#package-publishing-permissions)
  + [覆寫套件資產](#package-publishing-overwrite-assets)
  + [私有套件和公有儲存庫](#package-publishing-upstreams-direct)
  + [發佈修補的套件版本](#package-publishing-patched-versions)
  + [發佈的資產大小限制](#package-publishing-asset-size-limits)
  + [發佈延遲](#package-publishing-latency)
+ [套件版本狀態](#package-version-status)
+ [套件名稱、套件版本和資產名稱標準化](#package-name-normalization)

## 支援的套件格式
<a name="supported-package-formats"></a>

AWS CodeArtifact 支援 [Cargo](using-cargo.md)、 [generic](using-generic.md)、[Maven](using-maven.md)、[npm](using-npm.md)、[NuGet](using-nuget.md)、[PyPI](using-python.md)、[Ruby](using-ruby.md)、[Swift](using-swift.md) 套件格式。

## 套件發佈
<a name="package-publishing"></a>

 您可以使用 `npm`、、`twine`、、 `Maven``Gradle``nuget`和 等工具，將任何[支援套件格式](#supported-package-formats)的新版本發佈至 CodeArtifact 儲存庫`dotnet`。

### 發佈許可
<a name="package-publishing-permissions"></a>

您的 AWS Identity and Access Management (IAM) 使用者或角色必須具有發佈至目的地儲存庫的許可。發佈套件需要下列許可：
+ **貨物：** `codeartifact:PublishPackageVersion`
+ **一般：** `codeartifact:PublishPackageVersion`
+ **Maven：** `codeartifact:PublishPackageVersion` 和 `codeartifact:PutPackageMetadata`
+ **npm：** `codeartifact:PublishPackageVersion`
+ **NuGet：** `codeartifact:PublishPackageVersion` 和 `codeartifact:ReadFromRepository`
+ **Python：**`codeartifact:PublishPackageVersion`
+ **Ruby：** `codeartifact:PublishPackageVersion`
+ **Swift：** `codeartifact:PublishPackageVersion`

在上述許可清單中，您的 IAM 政策必須指定 `codeartifact:PublishPackageVersion`和 `codeartifact:PutPackageMetadata`許可`package`的資源。它還必須指定`codeartifact:ReadFromRepository`許可`repository`的資源。

如需 CodeArtifact 中許可的詳細資訊，請參閱 [AWS CodeArtifact 許可參考](auth-and-access-control-permissions-reference.md)。

### 覆寫套件資產
<a name="package-publishing-overwrite-assets"></a>

 您無法重新發佈已存在且具有不同內容的套件資產。例如，假設您已發佈具有 JAR 資產 的 Maven 套件`mypackage-1.0.jar`。只有在舊資產和新資產的檢查總和相同時，您才能再次發佈該資產。若要使用新內容重新發佈相同的資產，請先使用 **delete-package-versions**命令刪除套件版本。嘗試以不同的內容重新發佈相同的資產名稱會導致 HTTP 409 衝突錯誤。

 對於支援多個資產 （通用、PyPI 和 Maven) 的套件格式，您可以將不同名稱的新資產新增至現有的套件版本，前提是您具有必要的許可。對於一般套件，只要套件版本處於 `Unfinished` 狀態，您就可以新增資產。由於 npm 僅支援每個套件版本的單一資產，若要以任何方式修改已發佈的套件版本，您必須先使用 將其刪除**delete-package-versions**。

 如果您嘗試重新發佈已存在的資產 （例如 `mypackage-1.0.jar`)，且已發佈資產和新資產的內容相同，則操作會成功，因為操作是等冪的。

### 私有套件和公有儲存庫
<a name="package-publishing-upstreams-direct"></a>

 CodeArtifact 不會將儲存在 CodeArtifact 儲存庫中的套件發佈至公有儲存庫，例如 npmjs.com 或 Maven Central。CodeArtifact 會將套件從公有儲存庫匯入 CodeArtifact 儲存庫，但絕不會朝其他方向移動套件。您發佈至 CodeArtifact 儲存庫的套件會保持私有，且僅適用於您授予存取權 AWS 的帳戶、角色和使用者。

### 發佈修補的套件版本
<a name="package-publishing-patched-versions"></a>

 有時您可能想要發佈修改過的套件版本，可能是公有儲存庫中可用的版本。例如，您可能在名為 的關鍵應用程式相依性中發現錯誤`mydep 1.1`，而且您需要比套件廠商可以檢閱並接受變更更快修正。如前所述，如果公有儲存 CodeArtifact 庫可透過上游儲存庫和外部連線從 CodeArtifact 儲存庫存取，則 CodeArtifact 會防止您在 CodeArtifact 儲存庫`mydep 1.1`中發佈。

若要解決此問題，請將套件版本發佈至無法存取公有儲存庫的不同 CodeArtifact 儲存庫。然後使用 `copy-package-versions` API 將 的修補版本複製到您要使用它的 `mydep 1.1` CodeArtifact 儲存庫。

### 發佈的資產大小限制
<a name="package-publishing-asset-size-limits"></a>

可發佈的套件資產大小上限受限於 中顯示的**資產檔案大小上限**配額[配額 in AWS CodeArtifact](service-limits.md)。例如，您無法發佈大於目前資產檔案大小最大配額的 Maven JAR 或 Python 輪。如果您需要在 CodeArtifact 中存放較大的資產，請請求增加配額。

除了資產檔案大小配額上限之外，npm 套件的發佈請求大小上限為 2 GB。此限制與資產檔案大小最大配額無關，且無法隨著配額增加而提高。在 npm 發佈請求 (HTTP PUT) 中，套件中繼資料和 npm 套件 tar 封存的內容會綁定在一起。因此，可發佈的 npm 套件實際大小上限會有所不同，取決於包含中繼資料的大小。

**注意**  
發佈的 npm 套件的大小上限為小於 2 GB。

### 發佈延遲
<a name="package-publishing-latency"></a>

發佈至 CodeArtifact 儲存庫的套件版本通常可在一秒內下載。例如，如果您使用 將 npm 套件版本發佈至 CodeArtifact`npm publish`，則該版本應該可在一秒內供 `npm install`命令使用。不過，發佈可能不一致，有時可能需要更長的時間。如果您必須在發佈後立即使用套件版本，請使用重試以確保下載的可靠性。例如，發佈套件版本後，如果剛發佈的套件版本最初在第一次下載嘗試時不可用，請重複下載最多三次。

**注意**  
從公有儲存庫匯入套件版本通常需要比發佈更長的時間。如需詳細資訊，請參閱[外部連線延遲](external-connection-requesting-packages.md#external-connection-latency)。

## 套件版本狀態
<a name="package-version-status"></a>

CodeArtifact 中的每個套件版本都有一個狀態，描述套件版本的目前狀態和可用性。您可以在 AWS CLI 和 SDK 中變更套件版本狀態。如需詳細資訊，請參閱[更新套件版本狀態](update-package-version-status.md)。

以下是套件版本狀態的可能值：
+  **已發佈** – 套件版本已成功發佈，可以使用套件管理員請求。套件版本會包含在傳回給套件管理員的套件版本清單中，例如 的輸出中`npm view <package-name> versions`。套件版本的所有資產皆可從 儲存庫取得。
+  **未完成** – 用戶端已為套件版本上傳一或多個資產，但尚未將其移至 `Published` 狀態來完成。目前只有一般和 Maven 套件版本可以具有 的狀態`Unfinished`。對於 Maven 套件，當用戶端為套件版本上傳一或多個資產，但不為包含該版本的套件發佈`maven-metadata.xml`檔案時，就會發生這種情況。當 Maven 套件版本**未完成**時，將不會包含在傳回給用戶端的版本清單中，例如 `mvn`或 `gradle`，因此無法做為組建的一部分使用。在呼叫 [PublishPackageVersion](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PublishPackageVersion.html) API 時提供 `unfinished`旗標，即可刻意將一般套件保持在 `Unfinished` 狀態。您可以省略 `unfinished`旗標，或呼叫 [UpdatePackageVersionsStatus](https://docs.aws.amazon.com//codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) API，將一般套件變更為 `Published` 狀態。
+  **未列出** – 套件版本的資產可從儲存庫下載，但套件版本不包含在傳回套件管理員的版本清單中。例如，對於 npm 套件， 的輸出`npm view <package-name> versions`將不會包含套件版本。這表示 npm 的相依性解析邏輯不會選取套件版本，因為版本不會出現在可用版本清單中。不過，如果 `npm package-lock.json`檔案中已參考**未列出的**套件版本，仍然可以下載並安裝，例如在執行 時`npm ci`。
+  **已封存** – 無法再下載套件版本的資產。套件版本不會包含在傳回給套件管理員的版本清單中。由於資產無法使用，用戶端對套件版本的使用會遭到封鎖。如果您的應用程式建置取決於更新為**已封存**的版本，則建置會中斷，假設套件版本尚未在本機快取。您無法使用套件管理員或建置工具來重新發佈**封存套件**版本，因為它仍存在於儲存庫中，但您可以使用 [UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) 將套件版本的狀態變更回**未列出**或**已發佈**。
+  **已處置** – 套件版本不會顯示在清單中，且資產無法從儲存庫下載。**Disposed **和 **Archived** 之間的主要區別在於，狀態為 **Disposed** 時，CodeArtifact 會永久刪除套件版本的資產。因此，您無法將套件版本從**處置**移至**已封存**、**未列出**或**已發佈**。由於資產已刪除，因此無法再使用套件版本。套件版本標示為**已處置**後，您將不再支付套件資產的儲存費用。

呼叫 list-package-versions 時，預設會傳回所有狀態的套件版本，沒有`--status`參數。

 除了先前列出的狀態之外，也可以使用 [DeletePackageVersions API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html) 刪除套件版本。刪除後，套件版本不再位於儲存庫中，您可以使用套件管理員或建置工具自由重新發佈該套件版本。刪除套件版本後，您不再需要支付該套件版本資產的儲存費用。

## 套件名稱、套件版本和資產名稱標準化
<a name="package-name-normalization"></a>

CodeArtifact 會先標準化套件名稱、套件版本和資產名稱再儲存，這表示 CodeArtifact 中的名稱或版本可能與發佈套件時提供的名稱或版本不同。如需如何在 CodeArtifact 中針對每個套件類型標準化名稱和版本的詳細資訊，請參閱下列文件：
+ [Python 套件名稱標準化](python-name-normalization.md)
+ [NuGet 套件名稱、版本和資產名稱標準化](nuget-name-normalization.md)

CodeArtifact 不會在其他套件格式上執行標準化。

# 列出套件名稱
<a name="list-packages"></a>

使用 CodeArtifact 中的 `list-packages`命令，取得儲存庫中所有套件名稱的清單。此命令只會傳回套件名稱，而不會傳回版本。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo
```

輸出範例：

```
{
    "nextToken": "eyJidWNrZXRJZCI6I...",
    "packages": [
        {
            "package": "acorn",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        },
        {
            "package": "acorn-dynamic-import",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        },
        {
            "package": "ajv",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        },
        {
            "package": "ajv-keywords",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        },
        {
            "package": "anymatch",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        },
        {
            "package": "ast",
            "namespace": "webassemblyjs",
            "format": "npm",
            "originConfiguration": {
                "restrictions": {
                    "publish": "BLOCK",
                    "upstream": "ALLOW"
            }
        }
    ]
}
```

## 列出 npm 套件名稱
<a name="list-packages-npm"></a>

若要僅列出 npm 套件的名稱，請將 `--format`選項的值設定為 `npm`。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo  \
    --format npm
```

若要列出命名空間中的 npm 套件 (npm *範圍*)，請使用 `--namespace`和 `--format`選項。

**重要**  
`--namespace` 選項的值不應包含前置 `@`。若要搜尋命名空間 `@types`，請將 值設定為 *類型*。

**注意**  
`--namespace` 選項會依命名空間字首篩選。任何範圍開頭為傳遞給 `--namespace` 選項之值的 npm 套件，都會在`list-packages`回應中傳回。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo  \
    --format npm --namespace types
```

輸出範例：

```
{
    "nextToken": "eyJidWNrZXRJZ...",
    "packages": [
        {
            "package": "3d-bin-packing",
            "namespace": "types",
            "format": "npm"

        },
        {
            "package": "a-big-triangle",
            "namespace": "types",
            "format": "npm"

        },
        {
            "package": "a11y-dialog",
            "namespace": "types",
            "format": "npm"

        }
    ]
}
```

## 列出 Maven 套件名稱
<a name="list-packages-maven"></a>

若要僅列出 Maven 套件的名稱，請將 `--format`選項的值設定為 `maven`。您也必須在 `--namespace`選項中指定 Maven 群組 ID。

**注意**  
`--namespace` 選項會依命名空間字首篩選。任何範圍開頭為傳遞給 `--namespace` 選項之值的 npm 套件，都會在`list-packages`回應中傳回。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo  \
    --format maven --namespace org.apache.commons
```

輸出範例：

```
{
    "nextToken": "eyJidWNrZXRJZ...",
    "packages": [
        {
            "package": "commons-lang3",
            "namespace": "org.apache.commons",
            "format": "maven"

        },
        {
            "package": "commons-collections4",
            "namespace": "org.apache.commons",
            "format": "maven"

        },
        {
            "package": "commons-compress",
            "namespace": "org.apache.commons",
            "format": "maven"

        }
    ]
}
```

## 列出 Python 套件名稱
<a name="list-packages-python"></a>

若要僅列出 Python 套件的名稱，請將 `--format`選項的值設定為 `pypi`。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo  \
    --format pypi
```

## 依套件名稱字首篩選
<a name="list-packages-package-prefix"></a>

 若要傳回以指定字串開頭的套件，您可以使用 `--package-prefix`選項。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo  \
    --format npm --package-prefix pat
```

輸出範例：

```
{
    "nextToken": "eyJidWNrZXRJZ...",
    "packages": [
        {
            "package": "path",
            "format": "npm"

        },
        {
            "package": "pat-test",
            "format": "npm"

        },
        {
            "package": "patch-math3",
            "format": "npm"

        }
    ]
}
```

## 支援的搜尋選項組合
<a name="list-packages-option-combinations"></a>

您可以任意組合使用 `--format`、 `--namespace`和 `--package-prefix`選項，但 `--namespace` 本身無法使用。搜尋範圍開頭為 的所有 npm 套件`@types`，需要指定 `--format`選項。`--namespace` 單獨使用 會導致錯誤。

 也不支援使用這三個選項中的任何一個，`list-packages`而且 會傳回儲存庫中所有格式的所有套件。

## 格式輸出
<a name="list-packages-format-output"></a>

 您可以使用所有 AWS CLI 命令可用的參數，讓`list-packages`回應精簡且更易讀。使用 `--query` 參數來指定每個傳回套件版本的格式。使用 `--output` 參數將回應格式化為純文字。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo \
  --output text --query 'packages[*].[package]'
```

輸出範例：

```
accepts
array-flatten
body-parser
bytes
content-disposition
content-type
cookie
cookie-signature
```

 如需詳細資訊，請參閱 *AWS Command Line Interface 使用者指南*中的[控制 AWS CLI的命令輸出](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-output.html)。

## 預設值和其他選項
<a name="list-packages-defaults-options"></a>

 根據預設， 傳回的結果數目上限為 `list-packages` 100。您可以使用 `--max-results`選項變更此結果限制。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo --max-results 20
```

的允許值上限為 `--max-results` 1，000。若要允許列出具有超過 1，000 個套件的儲存庫中的套件， `list-packages`支援使用回應中的 `nextToken` 欄位進行分頁。如果儲存庫中的套件數目超過 的值`--max-results`，您可以將 的值傳遞`nextToken`給另一個叫用 `list-packages`，以取得下一頁的結果。

```
aws codeartifact list-packages --domain my_domain --domain-owner 111122223333 --repository my_repo \
  --next-token rO0ABXNyAEdjb...
```

# 列出套件版本
<a name="list-packages-versions"></a>

使用 in AWS CodeArtifact `list-package-versions`命令來取得儲存庫中套件名稱的所有版本清單。

```
aws codeartifact list-package-versions --package kind-of \ 
--domain my_domain --domain-owner 111122223333 \
--repository my_repository --format npm
```

輸出範例：

```
{
  "defaultDisplayVersion": "1.0.1",
  "format": "npm",
  "package": "kind-of",
  "versions": [
      {
          "version": "1.0.1",
          "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
          "status": "Published",
          "origin": {
                "domainEntryPoint": {
                    "externalConnectionName": "public:npmjs"
                },
                "originType": "EXTERNAL"
            }
      },
      {
          "version": "1.0.0",
          "revision": "REVISION-SAMPLE-2-C752BEEF6D2CFC",
          "status": "Published",
          "origin": {
                "domainEntryPoint": {
                    "externalConnectionName": "public:npmjs"
                },
                "originType": "EXTERNAL"
            }
      },
      {
          "version": "0.1.2",
          "revision": "REVISION-SAMPLE-3-654S65A5C5E1FC",
          "status": "Published",
          "origin": {
                "domainEntryPoint": {
                    "externalConnectionName": "public:npmjs"
                },
                "originType": "EXTERNAL"
            }
      },
      {
          "version": "0.1.1",
          "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC"",
          "status": "Published",
          "origin": {
                "domainEntryPoint": {
                    "externalConnectionName": "public:npmjs"
                },
                "originType": "EXTERNAL"
            }
      },
      {
          "version": "0.1.0",
          "revision": "REVISION-SAMPLE-4-AF669139B772FC",
          "status": "Published",
          "origin": {
                "domainEntryPoint": {
                    "externalConnectionName": "public:npmjs"
                },
                "originType": "EXTERNAL"
            }
      }        
  ]
}
```

您可以將 `--status` 參數新增至`list-package-versions`呼叫，以根據套件版本狀態篩選結果。如需套件版本狀態的詳細資訊，請參閱 [套件版本狀態](packages-overview.md#package-version-status)。

 您可以使用 `list-package-versions``--max-results`和 `--next-token` 參數，從 分頁回應。針對 `--max-results`，指定從 1 到 1000 的整數，以指定單一頁面中傳回的結果數目。其預設值為 50。若要傳回後續頁面，請`list-package-versions`再次執行 ，並將先前命令輸出中收到`nextToken`的值傳遞給 `--next-token`。不使用 `--next-token`選項時，一律會傳回結果的第一頁。

 `list-package-versions` 命令不會列出上游儲存庫中的套件版本。不過，會列出上游儲存庫中套件版本在套件版本請求期間複製到儲存庫的參考。如需詳細資訊，請參閱[在 CodeArtifact 中使用上游儲存庫](repos-upstream.md)。

## 列出 npm 套件版本
<a name="list-packages-versions-npm"></a>

若要列出 npm 套件的所有套件版本，請將 `--format`選項的值設定為 `npm`。

```
aws codeartifact list-package-versions --package my_package --domain my_domain \ 
 --domain-owner 111122223333 --repository my_repo --format npm
```

若要列出特定命名空間中的 npm 套件版本 (npm *範圍*)，請使用 `--namespace`選項。`--namespace` 選項的值不應包含前置 `@`。若要搜尋命名空間 `@types`，請將 值設定為 *類型*。

```
aws codeartifact list-package-versions --package my_package --domain my_domain \
 --domain-owner 111122223333 --repository my_repo --format npm \
 --namespace types
```

## 列出 Maven 套件版本
<a name="list-packages-versions-maven"></a>

若要列出 Maven 套件的所有套件版本，請將 `--format`選項的值設定為 `maven`。您也必須在 `--namespace`選項中指定 Maven 群組 ID。

```
aws codeartifact list-package-versions --package my_package --domain my_domain \
 --domain-owner 111122223333 --repository my_repo --format maven \
 --namespace org.apache.commons
```

## 排序版本
<a name="list-package-versions-sorting"></a>

 `list-package-versions` 可以輸出根據發佈時間以遞減順序排序的版本 （最新發佈的版本會先列出）。使用 值為 的 `--sort-by` 參數`PUBLISHED_TIME`，如下所示。

```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repository  \
--format npm --package webpack --max-results 5 --sort-by PUBLISHED_TIME
```

 輸出範例：

```
{

  "defaultDisplayVersion": "4.41.2",
  "format": "npm",
  "package": "webpack",
  "versions": [
      { 
        "version": "5.0.0-beta.7", 
        "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
        "status": "Published"
      },
      { 
        "version": "5.0.0-beta.6", 
        "revision": "REVISION-SAMPLE-2-C752BEEF6D2CFC",
        "status": "Published" 
      },
      { 
        "version": "5.0.0-beta.5", 
        "revision": "REVISION-SAMPLE-3-654S65A5C5E1FC",
        "status": "Published"
      },
      { 
        "version": "5.0.0-beta.4", 
        "revision": "REVISION-SAMPLE-4-AF669139B772FC",
        "status": "Published"
      },
      { 
        "version": "5.0.0-beta.3", 
        "revision": "REVISION-SAMPLE-5-C752BEE9B772FC",
        "status": "Published"
      }
  ],
  "nextToken": "eyJsaXN0UGF...."
}
```

## 預設顯示版本
<a name="list-package-versions-default-version"></a>

 的傳回值`defaultDisplayVersion`取決於套件格式：
+  對於一般、Maven 和 PyPI 套件，這是最近發佈的套件版本。
+  對於 npm 套件，它是`latest`標籤參考的版本。如果未設定`latest`標籤，則它是最近發佈的套件版本。

## 格式輸出
<a name="list-package-versions-format-output"></a>

 您可以使用所有 AWS CLI 命令可用的參數，讓`list-package-versions`回應精簡且更易讀。使用 `--query` 參數來指定每個傳回套件版本的格式。使用 `--output` 參數將回應格式化為純文字。

```
aws codeartifact list-package-versions --package my-package-name --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format npm --output text --query 'versions[*].[version]'
```

輸出範例：

```
0.1.1
0.1.2
0.1.0
3.0.0
```

 如需詳細資訊，請參閱*AWS Command Line Interface 《 使用者指南*》中的[從 控制命令輸出 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-output.html)。

# 列出套件版本資產
<a name="list-assets"></a>

*資產*是儲存在 CodeArtifact 中的個別檔案 （例如，npm `.tgz` 檔案或 Maven POM 或 JAR 檔案），與套件版本相關聯。您可以使用 `list-package-version-assets`命令列出每個套件版本中的資產。

執行 `list-package-version-assets`命令，以傳回您 AWS 帳戶和目前 AWS 區域中每個資產的下列相關資訊：
+  其名稱。
+  其大小，以位元組為單位。
+  一組用於檢查總和驗證的雜湊值。

例如，使用下列命令列出 Python 套件 `flatten-json`版本 的資產`0.1.7`。

```
aws codeartifact list-package-version-assets --domain my_domain --domain-owner 111122223333 \
 --repository my_repo --format pypi --package flatten-json \
 --package-version 0.1.7
```

以下將顯示輸出。

```
{
    "format": "pypi",
    "package": "flatten-json",
    "version": "0.1.7",
    "versionRevision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
    "assets": [
        {
            "name": "flatten_json-0.1.7-py3-none-any.whl",
            "size": 31520,
            "hashes": {
                "MD5": "41bba98d5b9219c43089eEXAMPLE-MD5",
                "SHA-1": "69b215c25dd4cda1d997a786ec6EXAMPLE-SHA-1",
                "SHA-256": "43f24850b7b7b7d79c5fa652418518fbdf427e602b1edabe6EXAMPLE-SHA-256",
                "SHA-512": "3947382ac2c180ee3f2aba4f8788241527c8db9dfe9f4b039abe9fc560aaf5a1fced7bd1e80a0dca9ce320d95f0864e0dec3ac4f2f7b2b2cbEXAMPLE-SHA-512"
            }
        },
        {
            "name": "flatten_json-0.1.7.tar.gz",
            "size": 2865,
            "hashes": {
                "MD5": "41bba98d5b9219c43089eEXAMPLE-MD5",
                "SHA-1": "69b215c25dd4cda1d997a786ec6EXAMPLE-SHA-1",
                "SHA-256": "43f24850b7b7b7d79c5fa652418518fbdf427e602b1edabe6EXAMPLE-SHA-256",
                "SHA-512": "3947382ac2c180ee3f2aba4f8788241527c8db9dfe9f4b039abe9fc560aaf5a1fced7bd1e80a0dca9ce320d95f0864e0dec3ac4f2f7b2b2cbEXAMPLE-SHA-512"
            }
        }
    ]
}
```

## 列出 npm 套件的資產
<a name="list-assets-npm"></a>

npm 套件一律具有名為 的單一資產`package.tgz`。若要列出範圍 npm 套件的資產，請在 `--namespace`選項中包含範圍。

```
aws codeartifact list-package-version-assets --domain my_domain --domain-owner 111122223333 \
 --repository my_repo --format npm --package webpack \
 --namespace types --package-version 4.9.2
```

## 列出 Maven 套件的資產
<a name="list-assets-maven"></a>

若要列出 Maven 套件的資產，請在 `--namespace`選項中包含套件命名空間。若要列出 Maven 套件 的資產`commons-cli:commons-cli`：

```
aws codeartifact list-package-version-assets --domain my_domain --domain-owner 111122223333 \
 --repository my_repo --format maven --package commons-cli \
 --namespace commons-cli --package-version 1.0
```

# 下載套件版本資產
<a name="download-assets"></a>

*資產*是儲存在 CodeArtifact 中的個別檔案 （例如，npm `.tgz` 檔案或 Maven POM 或 JAR 檔案），與套件版本相關聯。您可以使用 下載套件資產`get-package-version-assets command`。這可讓您擷取資產，而無需使用套件管理員用戶端，例如 `npm`或 `pip`。若要下載資產，您必須提供可使用 `list-package-version-assets`命令取得的資產名稱，如需詳細資訊，請參閱 [列出套件版本資產](list-assets.md)。資產將以您指定的檔案名稱下載至本機儲存體。

下列範例會從版本為 *27.1-jre *的 Maven 套件 *com.google.guava：guava* 下載 guava-*27.1-jre*.jar 資產。

```
aws codeartifact get-package-version-asset --domain my_domain --domain-owner 111122223333 --repository my_repo \
    --format maven --namespace com.google.guava --package guava --package-version 27.1-jre \
    --asset guava-27.1-jre.jar \
    guava-27.1-jre.jar
```

 在此範例中，檔案名稱由上述命令中的最後一個引數指定為 *guava-27.1-jre.jar*，因此下載的資產將命名為 *guava-27.1-jre.jar。*

命令的輸出將是：

```
{
    "assetName": "guava-27.1-jre.jar",
    "packageVersion": "27.1-jre",
    "packageVersionRevision": "YGp9ck2tmy03PGSxioclfYzQ0BfTLR9zzhQJtERv62I="
}
```

**注意**  
若要從範圍 npm 套件下載資產，請在 `--namespace`選項中包含範圍。使用 時，必須省略 `@`符號`--namespace`。例如，如果範圍為 `@types`，請使用 `--namespace types`。

 使用 下載資產`get-package-version-asset`需要套件資源的`codeartifact:GetPackageVersionAsset`許可。如需資源型許可政策的詳細資訊，請參閱*AWS Identity and Access Management 《 使用者指南*》中的[資源型政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_resource-based)。

# 在儲存庫之間複製套件
<a name="copy-package"></a>

您可以在 CodeArtifact 中將套件版本從一個儲存庫複製到另一個儲存庫。這對於套件提升工作流程或團隊或專案之間共用套件版本等案例很有幫助。來源和目的地儲存庫必須位於相同的網域中，才能複製套件版本。

## 複製套件所需的 IAM 許可
<a name="copypackageversions-iam-actions"></a>

若要在 CodeArtifact 中複製套件版本，呼叫使用者必須具有必要的 IAM 許可，且連接至來源和目的地儲存庫的資源型政策必須具有必要的許可。如需以資源為基礎的許可政策和 CodeArtifact 儲存庫的詳細資訊，請參閱 [儲存庫政策](repo-policies.md)。

呼叫 的使用者`copy-package-versions`必須擁有來源儲存庫的 `ReadFromRepository` 許可，以及目的地儲存庫的 `CopyPackageVersions`許可。

來源儲存庫必須擁有 `ReadFromRepository`許可，而目的地儲存庫必須擁有指派給 IAM 帳戶或使用者複製套件的 `CopyPackageVersions` 許可。下列政策是使用 `put-repository-permissions-policy`命令新增至來源儲存庫或目的地儲存庫的範例儲存庫政策。將 *111122223333* 取代為呼叫 的帳戶 ID`copy-package-versions`。

**注意**  
如果存在，呼叫 `put-repository-permissions-policy`將取代目前的儲存庫政策。您可以使用 `get-repository-permissions-policy`命令來查看政策是否存在，如需詳細資訊，請參閱 [讀取政策](repo-policies.md#reading-a-policy)。如果政策確實存在，您可能想要將這些許可新增至政策，而不是取代它。

**範例來源儲存庫許可政策**

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Action": [
                "codeartifact:ReadFromRepository"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::111122223333:root"
            },
            "Resource": "*"
        }
    ]
}
```

------

**範例目的地儲存庫許可政策**

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Action": [
                "codeartifact:CopyPackageVersions"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::111122223333:root"
            },
            "Resource": "*"
        }
    ]
}
```

------

## 複製套件版本
<a name="copy-package-versions"></a>

使用 CodeArtifact 中的 `copy-package-versions`命令，將一或多個套件版本從來源儲存庫複製到相同網域中的目的地儲存庫。下列範例會將名為 的 npm 套件版本 6.0.2 和 4.0.0 `my-package` 從`my_repo`儲存庫複製到`repo-2`儲存庫。

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository my_repo \
 --destination-repository repo-2 --package my-package --format npm \
 --versions 6.0.2 4.0.0
```

您可以在單一操作中複製相同套件名稱的多個版本。若要複製不同套件名稱的版本，您必須`copy-package-versions`針對每個套件名稱呼叫 。

先前的命令會產生下列輸出，假設兩個版本都可以成功複製。

```
{
   "successfulVersions": {
        "6.0.2": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        },
        "4.0.0": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

## 從上游儲存庫複製套件
<a name="copy-package-upstream"></a>

一般而言， `copy-package-versions`只會在 `--source-repository`選項指定的儲存庫中尋找要複製的版本。不過，您可以使用 `--include-from-upstream`選項，從來源儲存庫及其上游儲存庫複製版本。如果您使用 CodeArtifact SDK，請呼叫 `includeFromUpstream` 參數設為 true 的 `CopyPackageVersions` API。如需詳細資訊，請參閱[在 CodeArtifact 中使用上游儲存庫](repos-upstream.md)。

## 複製範圍 npm 套件
<a name="copying-a-scoped-npm-package"></a>

 若要複製範圍內的 npm 套件版本，請使用 `--namespace`選項來指定範圍。例如，若要複製套件 `@types/react`，請使用 `--namespace types`。使用 時，必須省略 `@`符號`--namespace`。

```
aws codeartifact copy-package-versions  --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace types \
 --package react --versions 0.12.2
```

## 複製 Maven 套件版本
<a name="copying-a-maven-package"></a>

若要在儲存庫之間複製 Maven 套件版本，請使用 `--namespace`選項傳遞 Maven 群組 ID，並使用 `--name`選項傳遞 Maven artifactID，以指定要複製的套件。例如，若要複製單一版本的 `com.google.guava:guava`：

```
 aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333  \
 --source-repository my_repo --destination-repository repo-2 --format maven --namespace com.google.guava \
 --package guava --versions 27.1-jre
```

如果成功複製套件版本，輸出將類似於以下內容。

```
{
    "successfulVersions": {
        "27.1-jre": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

## 來源儲存庫中不存在的版本
<a name="versions-that-do-not-exist-in-the-source-repository"></a>

如果您指定的版本不存在於來源儲存庫中，複製將會失敗。如果來源儲存庫中存在某些版本，但有些版本不存在，則所有版本都將無法複製。在下列範例中，來源儲存庫中存在 npm `array-unique` 套件的 0.2.0 版，但 5.6.7 版不是：

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm \
         --package array-unique --versions 0.2.0 5.6.7
```

此案例中的輸出將類似於以下內容。

```
{
    "successfulVersions": {},
    "failedVersions": {
        "0.2.0": {
            "errorCode": "SKIPPED",
            "errorMessage": "Version 0.2.0 was skipped"
        },
        "5.6.7": {
            "errorCode": "NOT_FOUND",
            "errorMessage": "Could not find version 5.6.7"
        }
    }
}
```

`SKIPPED` 錯誤碼用於表示版本未複製到目的地儲存庫，因為無法複製另一個版本。

## 已存在於目的地儲存庫的版本
<a name="versions-that-already-exist-in-the-destination-repository"></a>

 當套件版本複製到已存在的儲存庫時，CodeArtifact 會比較兩個儲存庫中的套件資產和套件版本層級中繼資料。

 如果來源和目的地儲存庫中的套件版本資產和中繼資料相同，則不會執行複本，但操作會被視為成功。這表示 `copy-package-versions`是等冪的。發生這種情況時，來源和目的地儲存庫中已存在的版本將不會列在 的輸出中`copy-package-versions`。

在下列範例中，來源儲存庫 中`array-unique`存在兩個版本的 npm 套件`repo-1`。版本 0.2.1 也存在於目的地儲存庫中，`dest-repo`而版本 0.2.0 則不存在。

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm --package array-unique \
         --versions 0.2.1 0.2.0
```

此案例中的輸出將類似於以下內容。

```
{
    "successfulVersions": {
        "0.2.0": {
            "revision": "Yad+B1QcBq2kdEVrx1E1vSfHJVh8Pr61hBUkoWPGWX0=",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

0.2.0 版已列在 中，`successfulVersions`因為它已成功從來源複製到目的地儲存庫。輸出中不會顯示 0.2.1 版，因為它已存在於目的地儲存庫中。

 如果來源和目的地儲存庫中的套件版本資產或中繼資料不同，複製操作將會失敗。您可以使用 `--allow-overwrite` 參數來強制覆寫。

如果某些版本存在於目的地儲存庫中，而有些版本不存在，則所有版本將無法複製。在下列範例中，來源和目的地儲存庫中都存在 `array-unique` npm 套件的 0.3.2 版，但套件版本的內容不同。版本 0.2.1 存在於來源儲存庫中，但目的地不存在。

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm --package array-unique \
         --versions 0.3.2 0.2.1
```

此案例中的輸出將類似於以下內容。

```
{
    "successfulVersions": {},
    "failedVersions": {
        "0.2.1": {
            "errorCode": "SKIPPED",
            "errorMessage": "Version 0.2.1 was skipped"
        },
        "0.3.2": {
            "errorCode": "ALREADY_EXISTS",
            "errorMessage": "Version 0.3.2 already exists"
        }
    }
}
```

版本 0.2.1 會標示為 ，`SKIPPED`因為它未複製到目的地儲存庫。因為 0.3.2 版的複本已存在於目的地儲存庫中，但在來源和目的地儲存庫中不同，所以未複製。

## 指定套件版本修訂
<a name="specify-package-version-revision"></a>

 套件版本修訂是一種字串，可指定套件版本的特定資產和中繼資料集。您可以指定套件版本修訂，以複製處於特定狀態的套件版本。若要指定套件版本修訂，請使用 `--version-revisions` 參數將一或多個逗號分隔的套件版本和套件版本修訂對傳遞至 `copy-package-versions`命令。

**注意**  
您必須使用 指定 `--versions`或 `--version-revisions` 參數`copy-package-versions`。您不能同時指定兩者。

下列範例只會在套件版本修訂版 的來源儲存庫中存在 `my-package` 0.3.2 版的套件時複製`REVISION-1-SAMPLE-6C81EFF7DA55CC`套件。

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace my-namespace \
 --package my-package --version-revisions 0.3.2=REVISION-1-SAMPLE-6C81EFF7DA55CC
```

下列範例會複製套件 0`my-package`.3.2 和 0.3.13 的兩個版本。只有當 的來源儲存庫 0.3.2 版具有`my-package`修訂版 `REVISION-1-SAMPLE-6C81EFF7DA55CC`且 0.3.13 版具有修訂版 時，複製才會成功`REVISION-2-SAMPLE-55C752BEE772FC`。

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace my-namespace \
 --package my-package --version-revisions 0.3.2=REVISION-1-SAMPLE-6C81EFF7DA55CC,0.3.13=REVISION-2-SAMPLE-55C752BEE772FC
```

 若要尋找套件版本的修訂，請使用 `describe-package-version`或 `list-package-versions`命令。

 如需詳細資訊，請參閱 *CodeArtifact API 參考*中的 [套件版本修訂](codeartifact-concepts.md#welcome-concepts-package-version-revision)和 [CopyPackageVersion](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_CopyPackageVersions.html)。

## 複製 npm 套件
<a name="copying-npm-packages"></a>

 如需使用 npm 套件`copy-package-versions`之行為的詳細資訊，請參閱 [npm 標籤和 CopyPackageVersions API](npm-tags.md#tags-and-cpv)。

# 刪除套件或套件版本
<a name="delete-package"></a>

您可以使用 `delete-package-versions`命令一次刪除一或多個套件版本。若要從儲存庫完全移除套件，包括所有相關版本和組態，請使用 `delete-package`命令。套件可以存在於儲存庫中，而沒有任何套件版本。當使用 `delete-package-versions`命令刪除所有版本，或使用 `put-package-origin-configuration` API 操作建立套件時，可能會發生這種情況 （請參閱 [編輯套件原始伺服器控制項](package-origin-controls.md))。

**Topics**
+ [刪除套件 (AWS CLI)](#delete-package-CLI)
+ [刪除套件 (主控台)](#delete-package-console)
+ [刪除套件版本 (AWS CLI)](#delete-package-version-CLI)
+ [刪除套件版本 (主控台)](#delete-package-version-console)
+ [刪除 npm 套件或套件版本](#delete-package-npm)
+ [刪除 Maven 套件或套件版本](#delete-package-maven)
+ [刪除套件或套件版本的最佳實務](#delete-package-bp)

## 刪除套件 (AWS CLI)
<a name="delete-package-CLI"></a>

您可以使用 `delete-package`命令刪除套件，包括其所有套件版本和組態。下列範例會刪除`my_domain`網域中儲存庫`my-package`中名為 `my_repo`的 PyPI 套件：

```
aws codeartifact delete-package --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format pypi \
--package my-package
```

輸出範例：

```
{
   "deletedPackage": { 
      "format": "pypi",
      "originConfiguration": { 
         "restrictions": { 
            "publish": "ALLOW",
            "upstream": "BLOCK"
         }
      },
      "package": "my-package"
   }
}
```

您可以針對`describe-package`相同的套件名稱執行 ，以確認套件已刪除：

```
aws codeartifact describe-package --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format pypi --package my-package
```

## 刪除套件 (主控台)
<a name="delete-package-console"></a>

1. 開啟位於 https：//[https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home) 的 AWS CodeArtifact 主控台。

1. 在導覽窗格中，選擇 **Repositories** (儲存庫)。

1. 選擇您要從中刪除套件的**儲存庫**。

1. 選擇您要刪除的**套件**。

1. 選擇**刪除套件**。

## 刪除套件版本 (AWS CLI)
<a name="delete-package-version-CLI"></a>

您可以使用 `delete-package-versions`命令一次刪除一或多個套件版本。下列範例會刪除`my_domain`網域`my_repo`中 `my-package` 中名為 `5.0.0`的 PyPI `4.0.0`套件版本 `4.0.1`、 和 ：

```
aws codeartifact delete-package-versions --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format pypi \
--package my-package --versions 4.0.0 4.0.1 5.0.0
```

輸出範例：

```
{
   "successfulVersions": {
      "4.0.0": {
         "revision": "oxwwYC9dDeuBoCt6+PDSwL6OMZ7rXeiXy44BM32Iawo=",
            "status": "Deleted"
      },
      "4.0.1": {
         "revision": "byaaQR748wrsdBaT+PDSwL6OMZ7rXeiBKM0551aqWmo=",
            "status": "Deleted"
      },
      "5.0.0": {
         "revision": "yubm34QWeST345ts+ASeioPI354rXeiSWr734PotwRw=",
            "status": "Deleted"
      }
   },
   "failedVersions": {}
}
```

您可以針對`list-package-versions`相同的套件名稱執行 ，以確認已刪除版本：

```
aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format pypi --package my-package
```

## 刪除套件版本 (主控台)
<a name="delete-package-version-console"></a>

1. 開啟位於 https：//[https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home) 的 AWS CodeArtifact 主控台。

1. 在導覽窗格中，選擇 **Repositories** (儲存庫)。

1. 選擇您要從中刪除套件版本的**儲存庫**。

1. 選擇您要從中刪除版本的**套件**。

1. 選取您要刪除的**套件版本**。

1. 選擇 **刪除**。
**注意**  
在 主控台中，您一次只能刪除一個套件版本。若要一次刪除多個 ，請使用 CLI。

## 刪除 npm 套件或套件版本
<a name="delete-package-npm"></a>

若要刪除 npm 套件或個別套件版本，請將 `--format`選項設定為 `npm`。若要刪除範圍 npm 套件中的套件版本，請使用 `--namespace`選項來指定範圍。例如，若要刪除套件 `@types/react`，請使用 `--namespace types`。使用 時省略 `@`符號`--namespace`。

```
aws codeartifact delete-package-versions --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format npm --namespace types \
--package react --versions 0.12.2
```

若要刪除套件 `@types/react`，包括其所有版本：

```
aws codeartifact delete-package --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format npm --namespace types \
--package react
```

## 刪除 Maven 套件或套件版本
<a name="delete-package-maven"></a>

若要刪除 Maven 套件或個別套件版本，請將 `--format`選項設定為 ，`maven`並使用 `--namespace`選項傳遞 Maven 群組 ID，並使用 選項傳遞 Maven artifactID，以指定要刪除的套件`--name`。例如，以下說明如何刪除單一版本的 `com.google.guava:guava`：

```
 aws codeartifact delete-package-versions --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format maven --namespace com.google.guava \
--package guava --versions 27.1-jre
```

下列範例示範如何刪除套件 `com.google.guava:guava`，包括其所有版本：

```
 aws codeartifact delete-package --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format maven --namespace com.google.guava \
--package guava
```

## 刪除套件或套件版本的最佳實務
<a name="delete-package-bp"></a>

如果您需要刪除套件版本，最佳實務是建議您建立儲存庫，以存放您要刪除之套件版本的備份副本。您可以先呼叫`copy-package-versions`備份儲存庫來執行此操作：

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository my_repo \
 --destination-repository repo-2 --package my-package --format npm \
 --versions 6.0.2 4.0.0
```

複製套件版本後，您就可以在要刪除的套件或套件版本`delete-package-versions`上呼叫 。

```
aws codeartifact delete-package-versions --domain my_domain --domain-owner 111122223333 \
--repository my_repo --format pypi \
--package my-package --versions 4.0.0 4.0.1 5.0.0
```

# 檢視和更新套件版本詳細資訊和相依性
<a name="describe-package-version"></a>

您可以在 CodeArtifact 中檢視套件版本的相關資訊，包括相依性。您也可以更新套件版本的狀態。如需套件版本狀態的詳細資訊，請參閱 [套件版本狀態](packages-overview.md#package-version-status)。

## 檢視套件版本詳細資訊
<a name="view-package-details"></a>

 使用 `describe-package-version`命令來檢視套件版本的詳細資訊。套件版本詳細資訊會在發佈至 CodeArtifact 時從套件中擷取。不同套件中的詳細資訊會有所不同，取決於其格式，以及作者新增至其中的資訊量。

 `describe-package-version` 命令輸出中的大多數資訊取決於套件格式。例如， 會從其`package.json`檔案`describe-package-version`擷取 npm 套件的資訊。此修訂由 CodeArtifact 建立。如需詳細資訊，請參閱[指定套件版本修訂](copy-package.md#specify-package-version-revision)。

 如果兩個名稱相同的套件版本都位於不同的命名空間中，則可以位於相同的儲存庫中。使用選用`--namespace`參數來指定命名空間。如需詳細資訊，請參閱 [檢視 npm 套件版本詳細資訊](#describe-package-version-npm) 或 [檢視 Maven 套件版本詳細資訊](#describe-package-version-maven) 。

 下列範例會傳回儲存`my_repo`庫中名為 `1.9.0`之 Python `pyhamcrest` 套件版本的詳細資訊。

```
aws codeartifact describe-package-version --domain my_domain --domain-owner 111122223333 --repository my_repo \
--format pypi --package pyhamcrest --package-version 1.9.0
```

 輸出可能如下所示。

```
{
  "format": "pypi",
  "package": "PyHamcrest",
  "displayName": "PyHamcrest",
  "version": "1.9.0",
  "summary": "Hamcrest framework for matcher objects",
  "homePage": "https://github.com/hamcrest/PyHamcrest",
  "publishedTime": 1566002944.273,
  "licenses": [
    {
      "id": "license-id",
      "name": "license-name"
    }
  ],
  "revision": "REVISION-SAMPLE-55C752BEE9B772FC"
}
```

**注意**  
CodeArtifact 會從套件作者提供的中繼資料中擷取套件版本詳細資訊，例如套件首頁或套件授權資訊。如果此資訊中的任何一個超過 400 KB，即 DynamoDB 項目大小限制，CodeArtifact 將無法處理此類資料，而且您可能無法在主控台或 的回應中看到此資訊`describe-package-version`。例如，例如 [https://pypi.org/project/rapyd-sdk/](https://pypi.org/project/rapyd-sdk/) 的 python 套件具有非常大的授權欄位，因此 CodeArtifact 不會處理此資訊。

## 檢視 npm 套件版本詳細資訊
<a name="describe-package-version-npm"></a>

若要檢視 npm 套件版本的詳細資訊，請將 `--format`選項的值設定為 **npm**。或者，在 `--namespace`選項中包含套件版本命名空間 (npm *範圍*)。`--namespace` 選項的值不應包含前置 `@`。若要搜尋命名空間 `@types`，請將 值設定為 *類型*。

以下內容會傳回 `@types`範圍`webpack`中名為 `4.41.5`的 npm 套件版本詳細資訊。

```
aws codeartifact describe-package-version --domain my_domain --domain-owner 111122223333 --repository my_repo \
--format npm --package webpack --namespace types --package-version 4.41.5
```

 輸出可能如下所示。

```
{
  "format": "npm",
  "namespace": "types",
  "package": "webpack",
  "displayName": "webpack",
  "version": "4.41.5",
  "summary": "Packs CommonJs/AMD modules for the browser. Allows ... further output omitted for brevity",
  "homePage": "https://github.com/webpack/webpack",
  "sourceCodeRepository": "https://github.com/webpack/webpack.git",
  "publishedTime": 1577481261.09,
  "licenses": [
    {
      "id": "license-id",
      "name": "license-name"
    }
  ],
  "revision": "REVISION-SAMPLE-55C752BEE9B772FC",
  "status": "Published",
  "origin": {
            "domainEntryPoint": {
                "externalConnectionName": "public:npmjs"
            },
            "originType": "EXTERNAL"
  }
}
```

## 檢視 Maven 套件版本詳細資訊
<a name="describe-package-version-maven"></a>

若要檢視 Maven 套件版本的詳細資訊，請將 `--format`選項的值設定為 ，`maven`並在 `--namespace`選項中包含套件版本命名空間。

 下列範例會傳回命名`org.apache.commons`空間和`my_repo`儲存庫`commons-rng-client-api`中名為 `1.2`之 Maven 套件版本的詳細資訊。

```
aws codeartifact describe-package-version --domain my_domain --domain-owner 111122223333 --repository my_repo \
--format maven --namespace org.apache.commons --package commons-rng-client-api --package-version 1.2
```

 輸出可能如下所示。

```
{
  "format": "maven",
  "namespace": "org.apache.commons",
  "package": "commons-rng-client-api",
  "displayName": "Apache Commons RNG Client API",
  "version": "1.2",
  "summary": "API for client code that uses random numbers generators.",
  "publishedTime": 1567920624.849,
  "licenses": [],
  "revision": "REVISION-SAMPLE-55C752BEE9B772FC"
}
```

**注意**  
CodeArtifact 不會從父 POM 檔案擷取套件版本詳細資訊。指定套件版本的中繼資料只會包含該確切套件版本的 POM 中的資訊，而不會包含父 POM 或使用 POM `parent`標籤暫時參考的任何其他 POM。這表示 的輸出`describe-package-version`會省略依賴`parent`參考包含此中繼資料的 Maven 套件版本的中繼資料 （例如授權資訊）。

## 檢視套件版本相依性
<a name="view-package-dependencies"></a>

 使用 `list-package-version-dependencies`命令來取得套件版本的相依性清單。下列命令列出 `my_domain` 網域中儲存`my_repo`庫`4.41.5`中名為 `my-package`、版本 之 npm 套件的相依性。

```
aws codeartifact list-package-version-dependencies --domain my_domain --domain-owner 111122223333 --repository my_repo \
--format npm --package my-package --package-version 4.41.5
```

 輸出可能如下所示。

```
{
  "dependencies": [
    {
      "namespace": "webassemblyjs",
      "package": "ast",
      "dependencyType": "regular",
      "versionRequirement": "1.8.5"
    },
    {
      "namespace": "webassemblyjs",
      "package": "helper-module-context",
      "dependencyType": "regular",
      "versionRequirement": "1.8.5"
    },
    {
      "namespace": "webassemblyjs",
      "package": "wasm-edit",
      "dependencyType": "regular",
      "versionRequirement": "1.8.5"
    }
  ],
  "versionRevision": "REVISION-SAMPLE-55C752BEE9B772FC"
}
```

如需 dependencyType 欄位的支援值範圍，請參閱 *CodeArtifact API* 中的 [PackageDependency](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html) 資料類型。

## 檢視套件版本 readme 檔案
<a name="view-package-readme"></a>

 有些套件格式，例如 npm，包含 `README` 檔案。使用 `get-package-version-readme` 取得套件版本的 `README` 檔案。下列命令會傳回 `my_domain` 網域中儲存`my_repo`庫`4.41.5`中名為 `my-package`、版本 的 npm 套件`README`檔案。

**注意**  
CodeArtifact 不支援顯示一般或 Maven 套件中的讀我檔案。

```
aws codeartifact get-package-version-readme --domain my_domain --domain-owner 111122223333 --repository my_repo \
--format npm --package my-package --package-version 4.41.5
```

 輸出可能如下所示。

```
{  
  "format": "npm",
  "package": "my-package",
  "version": "4.41.5"
  "readme": "<div align=\"center\">\n   <a href=\https://github.com/webpack/webpack\"> ... more content ... \n",
  "versionRevision": "REVISION-SAMPLE-55C752BEE9B772FC"
}
```

# 更新套件版本狀態
<a name="update-package-version-status"></a>

CodeArtifact 中的每個套件版本都有一個狀態，描述套件版本的目前狀態和可用性。您可以使用 AWS CLI 和 主控台變更套件版本狀態。

**注意**  
如需套件版本狀態的詳細資訊，包括可用狀態的清單，請參閱 [套件版本狀態](packages-overview.md#package-version-status)。

## 更新套件版本狀態
<a name="updating-pv-status"></a>

設定套件版本的狀態可讓 控制套件版本的使用方式，而無需將其完全從儲存庫中刪除。例如，當套件版本的狀態為 時`Unlisted`，它仍然可以正常下載，但不會出現在傳回 等命令的套件版本清單中`npm view`。[UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) 允許在單一 API 呼叫中設定相同套件的多個版本的套件版本狀態。如需不同狀態的說明，請參閱 [套件概觀](packages-overview.md)。

使用 `update-package-versions-status`命令將套件版本的狀態變更為 `Published`、 `Unlisted`或 `Archived`。若要查看使用 命令所需的 IAM 許可，請參閱 [更新套件版本狀態所需的 IAM 許可](#update-package-version-status-iam)。下列範例會將 npm 套件 4.1.0 版的狀態`chalk`設定為 `Archived`。

```
aws codeartifact update-package-versions-status --domain my_domain
 --domain-owner 111122223333 --repository my_repo --format npm --package chalk 
--versions 4.1.0 --target-status Archived
```

輸出範例：

```
{
    "successfulVersions": {
        "4.1.0": {
            "revision": "+Oz8skWbwY3k8M6SrNIqNj6bVH/ax+CxvkJx+No5j8I=",
            "status": "Archived"
        }
    },
    "failedVersions": {}
}
```

此範例使用 npm 套件，但命令對其他格式的運作方式相同。您可以使用單一命令將多個版本移至相同的目標狀態，請參閱下列範例。

```
aws codeartifact update-package-versions-status --domain my_domain
 --domain-owner 111122223333 --repository my_repo --format npm --package chalk 
--versions 4.1.0 4.1.1 --target-status Archived
```

輸出範例：

```
{
    "successfulVersions": {
        "4.1.0": {
            "revision": "25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=",
            "status": "Archived"
        },
        "4.1.1": {
            "revision": "+Oz8skWbwY3k8M6SrNIqNj6bVH/ax+CxvkJx+No5j8I=",
            "status": "Archived"
        }
    },
    "failedVersions": {}
}
```

請注意，一旦發佈，套件版本就無法移回 `Unfinished` 狀態，因此不允許此狀態做為 `--target-status` 參數的值。若要將套件版本移至 `Disposed` 狀態，請改用 `dispose-package-versions`命令，如下所述。

## 更新套件版本狀態所需的 IAM 許可
<a name="update-package-version-status-iam"></a>

若要呼叫`update-package-versions-status`套件，您必須擁有套件資源的 `codeartifact:UpdatePackageVersionsStatus`許可。這表示您可以授予每個套件呼叫 `update-package-versions-status`的許可。例如，授予在 npm 套件 *chalk* `update-package-versions-status`上呼叫 許可的 IAM 政策會包含如下所示的陳述式。

```
{
  "Action": [
    "codeartifact:UpdatePackageVersionsStatus"
  ],
  "Effect": "Allow",
  "Resource": "arn:aws:codeartifact:us-east-1:111122223333:package/my_domain/my_repo/npm//chalk"
}
```

## 更新範圍 npm 套件的狀態
<a name="update-package-version-status-scoped-npm"></a>

若要使用範圍更新 npm 套件版本的套件版本狀態，請使用 `--namespace` 參數。例如，若要取消列出 的 8.0.0 版`@nestjs/core`，請使用下列命令。

```
aws codeartifact update-package-versions-status --domain my_domain
 --domain-owner 111122223333 --repository my_repo --format npm --namespace nestjs 
--package core --versions 8.0.0 --target-status Unlisted
```

## 更新 Maven 套件的狀態
<a name="update-package-version-status-maven"></a>

Maven 套件一律具有群組 ID，在 CodeArtifact 中稱為命名空間。呼叫 時，使用 `--namespace` 參數指定 Maven 群組 ID`update-package-versions-status`。例如，若要封存 Maven 套件 的 2.13.1 版`org.apache.logging.log4j:log4j`，請使用下列命令。

```
aws codeartifact update-package-versions-status --domain my_domain
 --domain-owner 111122223333 --repository my_repo --format maven 
--namespace org.apache.logging.log4j --package log4j 
--versions 2.13.1 --target-status Archived
```

## 指定套件版本修訂
<a name="update-status-specify-package-version-revision"></a>

套件版本修訂是指定套件版本特定資產和中繼資料集的字串。您可以指定套件版本修訂，以更新處於特定狀態的套件版本狀態。若要指定套件版本修訂，請使用 `--version-revisions` 參數傳遞一或多個逗號分隔的套件版本和套件版本修訂對。只有在套件版本的目前修訂版符合指定的值時，才會更新套件版本的狀態。

**注意**  
使用 `—-versions` 參數時，也必須定義 `--version-revisions` 參數。

```
aws codeartifact update-package-versions-status --domain my_domain 
   --domain-owner 111122223333 --repository my_repo --format npm --package chalk 
   --version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8bzVMJ4=" 
   --versions 4.1.0 --target-status Archived
```

若要使用單一命令更新多個版本，請將版本和版本修訂對的逗號分隔清單傳遞給`--version-revisions`選項。下列範例命令會定義兩個不同的套件版本和套件版本修訂對。

```
aws codeartifact update-package-versions-status --domain my_domain 
 --domain-owner 111122223333 --repository my_repo --format npm 
 --package chalk
 --version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=,4.0.0=E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc="  
 --versions 4.1.0 4.0.0 --target-status Published
```

輸出範例：

```
{
    "successfulVersions": {
        "4.0.0": {
            "revision": "E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc=",
            "status": "Published"
        },
        "4.1.0": {
            "revision": "25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

更新多個套件版本時，傳遞至 的版本`--version-revisions`必須與傳遞至 的版本相同`--versions`。如果未正確指定修訂，則該版本將不會更新其狀態。

## 使用預期的狀態參數
<a name="using-expected-status"></a>

`update-package-versions-status` 命令提供 `--expected-status` 參數，支援指定套件版本的預期目前狀態。如果目前狀態不符合傳遞給 的值`--expected-status`，則該套件版本的狀態將不會更新。

例如，在 *my\$1repo* 中，npm 套件的 4.0.0 和 4.1.0 版`chalk`目前狀態為 `Published`。由於狀態不相符`update-package-versions-status`，指定預期狀態 的 呼叫`Unlisted`將無法更新兩個套件版本。

```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --package chalk 
--versions 4.1.0 4.0.0 --target-status Archived --expected-status Unlisted
```

輸出範例：

```
{
    "successfulVersions": {},
    "failedVersions": {
        "4.0.0": {
            "errorCode": "MISMATCHED_STATUS",
            "errorMessage": "current status: Published, expected status: Unlisted"
        },
        "4.1.0": {
            "errorCode": "MISMATCHED_STATUS",
            "errorMessage": "current status: Published, expected status: Unlisted"
        }
    }
}
```

## 個別套件版本的錯誤
<a name="update-package-version-status-errors"></a>

呼叫 時，套件版本的狀態不會更新，原因有很多`update-package-versions-status`。例如，套件版本修訂可能未正確指定，或預期狀態與目前狀態不符。在這些情況下，版本會包含在 API 回應的`failedVersions`映射中。如果某個版本失敗，在對 的相同呼叫中指定的其他版本`update-package-versions-status`可能會略過，而不會更新其狀態。這類版本也會包含在具有 之 `errorCode`的`failedVersions`地圖中`SKIPPED`。

在 的目前實作中`update-package-versions-status`，如果一或多個版本無法變更其狀態，則會略過所有其他版本。也就是說，所有版本都會成功更新，或不會更新任何版本。API 合約不保證此行為；未來某些版本可能會成功，而其他版本在對 的單一呼叫中失敗`update-package-versions-status`。

下列範例命令包含因套件版本修訂不相符而導致的版本狀態更新失敗。該更新失敗會導致略過另一個版本狀態更新呼叫。

```
aws codeartifact update-package-versions-status --domain my_domain
  --domain-owner 111122223333 --repository my_repo 
  --format npm --package chalk 
  --version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ=,4.0.0=E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc=" 
  --versions 4.1.0 4.0.0 --target-status Archived
```

輸出範例：

```
{
    "successfulVersions": {},
    "failedVersions": {
        "4.0.0": {
            "errorCode": "SKIPPED",
            "errorMessage": "version 4.0.0 is skipped"
        },
        "4.1.0": {
            "errorCode": "MISMATCHED_REVISION",
            "errorMessage": "current revision: 25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=, expected revision: 25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ="
        }
    }
}
```

## 處置套件版本
<a name="dispose-package-versions"></a>

`Disposed` 套件狀態具有與 類似的行為`Archived`，但 CodeArtifact 將永久刪除套件資產，因此不會再向網域擁有者的帳戶收取資產儲存的費用。如需每個套件版本狀態的詳細資訊，請參閱 [套件版本狀態](packages-overview.md#package-version-status)。若要將套件版本的狀態變更為 `Disposed`，請使用 `dispose-package-versions`命令。此功能與 不同，`update-package-versions-status`因為處置套件版本是不可逆的。由於套件資產將被刪除，因此版本的狀態無法變更回 `Archived`、 `Unlisted`或 `Published`。對於已處置的套件版本，唯一可以採取的動作是使用 `delete-package-versions`命令將其刪除。

若要`dispose-package-versions`成功呼叫 ，呼叫的 IAM 主體必須具有套件資源的 `codeartifact:DisposePackageVersions` 許可。

`dispose-package-versions` 命令的行為類似於 `update-package-versions-status`，包括[版本修訂](#update-status-specify-package-version-revision)`--version-revisions `和[預期狀態](#using-expected-status)區段中所述的 和 `--expected-status`選項的行為。例如，下列命令會嘗試處置套件版本，但由於預期狀態不相符而失敗。

```
aws codeartifact dispose-package-versions —domain my_domain --domain-owner 111122223333 
--repository my_repo --format npm --package chalk --versions 4.0.0 
--expected-status Unlisted
```

輸出範例：

```
{
    "successfulVersions": {},
    "failedVersions": {
        "4.0.0": {
            "errorCode": "MISMATCHED_STATUS",
            "errorMessage": "current status: Published, expected status: Unlisted"
        }
    }
}
```

如果使用 `--expected-status`的 再次執行相同的命令`Published`，處置將會成功。

```
aws codeartifact dispose-package-versions —domain my_domain --domain-owner 111122223333 
--repository my_repo --format npm --package chalk --versions 4.0.0 
--expected-status Published
```

輸出範例：

```
{
    "successfulVersions": {
        "4.0.0": {
            "revision": "E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc=",
            "status": "Disposed"
        }
    },
    "failedVersions": {}
}
```

# 編輯套件原始伺服器控制項
<a name="package-origin-controls"></a>

在 AWS CodeArtifact 中，套件版本可以直接發佈、從上游儲存庫下提取或從外部公有儲存庫擷取，以新增至儲存庫。允許透過直接從公有儲存庫發佈和擷取來新增套件的套件版本，讓您容易遭受相依性替代攻擊。如需詳細資訊，請參閱[相依性替代攻擊](dependency-substitution-attacks.md)。為了保護自己免受相依性替代攻擊，您可以在儲存庫中的套件上設定套件原始伺服器控制，以限制該套件的版本可新增至儲存庫的方式。

任何想要允許不同套件新版本來自兩個內部來源的團隊，例如直接發佈和外部來源，例如公有儲存庫，都應考慮設定套件原始伺服器控制。根據預設，套件原始伺服器控制會根據套件的第一個版本新增至儲存庫的方式進行設定。如需套件原始控制設定及其預設值的詳細資訊，請參閱 [套件原始伺服器控制設定](#package-origin-control-settings)。

若要在使用 `put-package-origin-configuration` API 操作後移除套件記錄，請使用 `delete-package`（請參閱 [刪除套件或套件版本](delete-package.md))。

## 常見的套件存取控制案例
<a name="package-origin-control-scenarios"></a>

本節包含將套件版本新增至 CodeArtifact 儲存庫的一些常見案例。根據第一個套件版本的新增方式，將為新套件設定套件原始伺服器控制設定。

在下列案例中，*內部套件*是直接從套件管理員發佈到儲存庫的套件，例如您或您的團隊撰寫和維護的套件。*外部套件*是存在於公有儲存庫中的套件，可透過外部連線擷取到您的儲存庫。

**針對現有的內部套件發佈外部套件版本**

在此案例中，請考慮內部套件 *packageA*。您的團隊會將 *packageA* 的第一個套件版本發佈至 CodeArtifact 儲存庫。由於這是該套件的第一個套件版本，套件原始伺服器控制設定會自動設定為**發佈：允許**和**上游：封鎖**。套件存在於您的儲存庫之後，具有相同名稱的套件會發佈至連線至 CodeArtifact 儲存庫的公有儲存庫。這可能是對內部套件的嘗試相依性替代攻擊，也可能只是巧合。無論如何，套件原始伺服器控制都會設定為封鎖新外部版本的擷取，以保護自己免於潛在的攻擊。

在下圖中，*repoA* 是具有公有儲存庫外部連線的 CodeArtifact 儲存庫。您的儲存庫包含 *packageA* 的 1.1 和 2.1 版，但 3.0 版會發佈至公有儲存庫。通常，在套件管理員請求套件之後，*repoA* 會擷取 3.0 版。由於套件擷取設定為 **Block**，因此 3.0 版不會擷取到您的 CodeArtifact 儲存庫，且無法供與其連線的套件管理員使用。

![\[簡單圖顯示新的外部套件版本遭到公有儲存庫封鎖。\]](http://docs.aws.amazon.com/zh_tw/codeartifact/latest/ug/images/package-origin-controls-one.png)


**已發佈現有外部套件的內部套件版本**

在此案例中，套件 *packageB* 在外部存在於您已連線至儲存庫的公有儲存庫中。當套件管理員連接到您的儲存庫請求 *packageB* 時，套件版本會從公有儲存庫擷取到您的儲存庫。由於這是新增至儲存庫的第一個 *packageB* 套件版本，因此套件原始伺服器設定會設定為 **Publish： BLOCK** and **Upstream： ALLOW**。稍後，您會嘗試將具有相同套件名稱的版本發佈至儲存庫。您可能不知道公有套件並嘗試以相同名稱發佈不相關的套件，或者嘗試發佈修補版本，或者嘗試直接發佈已存在於外部的確切套件版本。CodeArtifact 會拒絕您嘗試發佈的版本，但可讓您明確覆寫拒絕，並視需要發佈版本。

在下圖中，*repoA* 是具有公有儲存庫外部連線的 CodeArtifact 儲存庫。您的儲存庫包含從公有儲存庫擷取的 3.0 版。您想要將 1.1 版發佈到您的儲存庫。一般而言，您可以將 1.2 版發佈至 *repoA*，但由於發佈設定為 **Block**，因此無法發佈 1.2 版。

![\[簡單圖顯示新的外部套件版本遭到公有儲存庫封鎖。\]](http://docs.aws.amazon.com/zh_tw/codeartifact/latest/ug/images/package-origin-controls-two.png)


**發佈現有外部套件的修補套件版本**

在此案例中，套件 *packageB* 在外部存在於您已連線至儲存庫的公有儲存庫中。當套件管理員連接到您的儲存庫請求 *packageB* 時，套件版本會從公有儲存庫擷取到您的儲存庫。由於這是新增至儲存庫的第一個 *packageB* 套件版本，因此套件原始伺服器設定會設定為 **Publish： BLOCK** and **Upstream： ALLOW**。您的團隊決定需要將此套件的修補套件版本發佈至儲存庫。為了能夠直接發佈套件版本，您的團隊會將套件原始伺服器控制設定變更為**發佈：允許**和**上游：封鎖**。此套件的版本現在可以直接發佈到您的儲存庫，並從公有儲存庫擷取。在您的團隊發佈修補的套件版本之後，您的團隊會將套件原始伺服器設定還原為 **Publish： BLOCK** and **Upstream： ALLOW**。

## 套件原始伺服器控制設定
<a name="package-origin-control-settings"></a>

透過套件原始伺服器控制，您可以設定如何將套件版本新增至儲存庫。下列清單包含可用的套件原始伺服器控制設定和值。

**注意**  
在套件群組上設定原始伺服器控制項時，可用的設定和值會有所不同。如需詳細資訊，請參閱[套件群組原始伺服器控制](package-group-origin-controls.md)。

**發布**

此設定會設定是否可使用套件管理員或類似工具，將套件版本直接發佈至儲存庫。
+ **允許**：可以直接發佈套件版本。
+ **封鎖**：無法直接發佈套件版本。

**上游**

此設定會設定套件版本是否可以從外部、公有儲存庫擷取，或在套件管理員要求時從上游儲存庫保留。
+ **允許**：任何套件版本都可以從設定為上游儲存庫的其他 CodeArtifact 儲存庫保留，或從具有外部連線的公有來源擷取。
+ **封鎖**：套件版本無法從設定為上游儲存庫的其他 CodeArtifact 儲存庫保留，或從具有外部連線的公有來源擷取。

## 預設套件原始控制設定
<a name="default-package-origin-control-settings"></a>

預設套件原始伺服器控制設定是根據套件相關聯的套件群組原始伺服器控制設定進行設定。如需套件群組和套件群組原始伺服器控制項的詳細資訊，請參閱 [在 CodeArtifact 中使用套件群組](package-groups.md)和 [套件群組原始伺服器控制](package-group-origin-controls.md)。

如果套件與每個限制類型的限制設定為 `ALLOW` 的套件群組相關聯，則套件的預設套件原始伺服器控制項將根據該套件的第一個版本如何新增至儲存庫。
+ 如果第一個套件版本是由套件管理員正確發佈，則設定會是 **Publish： ALLOW** 和 **Upstream： BLOCK**。
+ 如果從公有來源擷取第一個套件版本，則設定將是**發佈：封鎖**和**上游：允許**。

**注意**  
在 2022 年 5 月前後，CodeArtifact 儲存庫中存在的套件會有**發佈：允許**和**上游：允許**的預設套件原始伺服器控制。這類套件必須手動設定套件原始伺服器控制。目前預設值自那時起已在新套件上設定，並在 2022 年 7 月 14 日啟動此功能時開始強制執行。如需設定套件原始伺服器控制的詳細資訊，請參閱 [編輯套件原始伺服器控制項](#edit-package-origin-controls)。

否則，如果套件與具有至少一個限制設定 `BLOCK`或 的套件群組相關聯`ALLOW_SPECIFIC_REPOSITORIES`，則該套件的預設原始伺服器控制設定將設定為 **Publish： ALLOW** 和 **Upstream： ALLOW**。

## 套件原始伺服器控制如何與套件群組原始伺服器控制互動
<a name="package-origin-controls-interaction-package-groups"></a>

由於套件具有原始伺服器控制設定，且其相關聯的套件群組具有原始伺服器控制設定，因此請務必了解這兩個不同的設定如何彼此互動。

兩個設定之間的互動是 的設定`BLOCK`一律會勝過 的設定`ALLOW`。下表列出一些範例組態及其有效的原始伺服器控制設定。


| 套件原始伺服器控制設定 | 套件群組原始伺服器控制設定 | 有效的原始伺服器控制設定 | 
| --- | --- | --- | 
| PUBLISH：允許UPSTREAM：允許 | PUBLISH：允許UPSTREAM：允許 | PUBLISH：允許UPSTREAM：允許 | 
| PUBLISH：BLOCKUPSTREAM：允許 | PUBLISH：允許UPSTREAM：允許 | PUBLISH：BLOCKUPSTREAM：允許 | 
| PUBLISH：允許UPSTREAM：允許 | PUBLISH：允許UPSTREAM：封鎖 | PUBLISH：允許UPSTREAM：封鎖 | 

這表示原始伺服器設定為 **Publish： ALLOW** 和 **Upstream： ALLOW** 的套件，會有效地延遲至相關聯的套件群組原始伺服器控制設定。

## 編輯套件原始伺服器控制項
<a name="edit-package-origin-controls"></a>

套件原始伺服器控制項會根據套件的第一個套件版本如何新增至儲存庫來自動設定，如需詳細資訊，請參閱 [預設套件原始控制設定](#default-package-origin-control-settings)。若要新增或編輯 CodeArtifact 儲存庫中套件的套件原始伺服器控制項，請執行下列程序中的步驟。

**新增或編輯套件原始伺服器控制 （主控台）**

1. 開啟位於 https：//[https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home) 的 AWS CodeArtifact 主控台。

1. 在導覽窗格中，選擇**儲存庫**，然後選擇包含您要編輯之套件的儲存庫。

1. 在**套件**表格中，搜尋並選取您要編輯的套件。

1. 在套件摘要頁面的**原始伺服器控制項**中，選擇**編輯**。

1. 在**編輯原始伺服器控制項**中，選擇您要為此套件設定的套件原始伺服器控制項。套件原始控制設定 Publish 和 Upstream 必須同時設定。
   + 若要允許直接發佈套件版本，請在**發佈**中選擇**允許**。若要封鎖發佈套件版本，請選擇**封鎖**。
   + 若要允許從外部儲存庫擷取套件並從上游儲存庫提取套件，請在**上游來源**中選擇**允許**。若要封鎖所有從外部和上游儲存庫擷取和提取套件版本，請選擇**封鎖**。

**新增或編輯套件原始伺服器控制項 (AWS CLI)**

1. 如果您尚未設定 ， AWS CLI 請依照中的步驟進行設定[使用 AWS CodeArtifact 設定](get-set-up-for-codeartifact.md)。

1. 使用 `put-package-origin-configuration`命令來新增或編輯套件原始伺服器控制項。取代下列欄位：
   + 將 *my\$1domain* 取代為 CodeArtifact 網域，其中包含您要更新的套件。
   + 將 *my\$1repo* 取代為 CodeArtifact 儲存庫，其中包含您要更新的套件。
   + 將 *npm* 取代為您要更新的套件格式。
   + 將 *my\$1package* 取代為您要更新的套件名稱。
   + 將 *ALLOW* 和 *BLOCK* 取代為您想要的套件原始伺服器控制設定。

   ```
   aws codeartifact put-package-origin-configuration --domain my_domain \
   --repository my_repo --format npm --package my_package \ 
   --restrictions publish=ALLOW,upstream=BLOCK
   ```

## 發佈和上游儲存庫
<a name="package-publishing-upstreams"></a>

CodeArtifact 不允許發佈可連線上游儲存庫或公有儲存庫中存在的套件版本。例如，假設您想要將 Maven 套件發佈`com.mycompany.mypackage:1.0`至儲存庫 `myrepo`，且`myrepo`具有與 Maven Central 外部連線的上游儲存庫。請考慮下列案例。

1. 上的套件原始伺服器控制設定`com.mycompany.mypackage`是**發佈：允許**和**上游：允許**。如果上游儲存庫或 Maven Central 中存在 `com.mycompany.mypackage:1.0` ，CodeArtifact 會拒絕任何嘗試以 409 `myrepo` 衝突錯誤發佈至其中。您仍然可以發佈不同的版本，例如 `com.mycompany.mypackage:1.1`。

1. 上的套件原始伺服器控制設定`com.mycompany.mypackage`是 **Publish： ALLOW** 和 **Upstream： BLOCK**。您可以將任何 版本發佈`com.mycompany.mypackage`至尚未存在的儲存庫，因為套件版本無法連線。

1. 上的套件原始伺服器控制設定`com.mycompany.mypackage`是 **Publish： BLOCK** and **Upstream： ALLOW**。您無法將任何套件版本直接發佈到您的儲存庫。