

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 处理中的软件包 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 [[支持 C [argo、g](using-cargo.md) enerial、[Maven](using-maven.md)、[npm](using-npm.md)、、[NuGet](using-nuget.md)p [yPI、[Ruby](using-ruby.md)、Sw](using-python.md) ift 包格式。](using-swift.md)](using-generic.md)

## 程序包发布
<a name="package-publishing"></a>

 您可以使用诸如`npm`、、、、`twine`和之类的工具将任何[支持的软件包格式](#supported-package-formats)的新版本发布到 CodeArtifact 存储库`dotnet`。`Maven` `Gradle` `nuget`

### 发布权限
<a name="package-publishing-permissions"></a>

您的 AWS Identity and Access Management (IAM) 用户或角色必须具有发布到目标存储库的权限。发布程序包需要以下权限：
+ **Cargo：**`codeartifact:PublishPackageVersion`
+ **通用：**`codeartifact:PublishPackageVersion`
+ **Maven：**`codeartifact:PublishPackageVersion` 和 `codeartifact:PutPackageMetadata`
+ **npm：**`codeartifact:PublishPackageVersion`
+ **NuGet:** `codeartifact:PublishPackageVersion` 和 `codeartifact:ReadFromRepository`
+ **Python：**`codeartifact:PublishPackageVersion`
+ **红宝石：**`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 资产 `mypackage-1.0.jar` 的 Maven 程序包。仅当新旧资产的校验和完全相同时，您才能再次发布该资产。要重新发布包含新内容的相同资产，请先使用 **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 禁止您在存储库中发布`mydep 1.1`。

要解决此问题，请将软件包版本发布到无法访问公共存储库的其他存储库。 CodeArtifact 然后使用 `copy-package-versions` API 将的修补版本复制`mydep 1.1`到您要从中使用它的 CodeArtifact 存储库。

### 发布的资产大小限制
<a name="package-publishing-asset-size-limits"></a>

可以发布的程序包资产的最大大小受**资产文件大小最大配额**的限制，如[中的配额 AWS CodeArtifact](service-limits.md)中所示。例如，您发布的 Maven JAR 或 Python Wheel 不能超过当前资产文件大小的最大配额。如果您需要在中存储更大的资产 CodeArtifact，请申请增加配额。

除了资产文件大小的最大配额外，npm 程序包发布请求的最大大小为 2 GB。此限制与资产文件大小的最大配额无关，不能随着配额的增加而提高。在 npm 发布请求 (HTTP PUT) 中，程序包元数据和 npm 程序包 tar 存档的内容捆绑在一起。因此，可以发布的 npm 程序包的实际最大大小会有所不同，具体取决于所包含元数据的大小。

**注意**  
已发布的 npm 包的最大大小限制为小于 2 GB。

### 发布延迟
<a name="package-publishing-latency"></a>

发布到 CodeArtifact 存储库的 Package 版本通常可以在不到一秒钟的时间内下载。例如，如果您将 npm 包版本发布到 wit CodeArtifact h`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` 时。
+  **已存档** - 无法再下载该程序包版本的资产。在返回给程序包管理器的版本列表中不会包括该程序包版本。由于资产不可用，因此会阻止客户端使用程序包版本。如果您的应用程序构建依赖于更新为**已存档**的版本，那么构建就会出问题，前提是该程序包版本尚未在本地缓存。[您不能使用包管理器或构建工具重新发布**存档**包版本，因为该版本仍存在于存储库中，但您可以使用 API 将包版本的状态更改回 “**未上市**” 或 “**UpdatePackageVersionsStatus 已发布**”。](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)
+  **已处置** - 程序包版本未出现在列表中，也无法从存储库下载资产。它们之间的主要区别在于**，**如果**处**置状态为 “已**处置**”，则软件包版本的资产将被永久删除 CodeArtifact。因此，您无法将程序包版本从**已处置**更改为**已存档**、**未列出**或**已发布**。由于已删除资产，因此无法再使用该程序包版本。将程序包版本标记为**已处置**后，我们将不再向您收取程序包资产的存储费用。

不 list-package-versions带`--status`参数调用时，将默认返回所有状态的 Package 版本。

 除了前面列出的状态外，还可以使用 [DeletePackageVersionsAPI](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>

使用中的`list-packages`命令 CodeArtifact 获取存储库中所有软件包名称的列表。此命令仅返回程序包名称，不返回版本。

```
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 *scope*) 中的 npm 程序包，请使用 `--namespace` 和 `--format` 选项。

**重要**  
`--namespace` 选项的值不得包括前导 `@`。要搜索命名空间`@types`，请将值设置为*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`。搜索作用域从 `@types` 开始的所有 npm 程序包需要指定 `--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>

使用中的`list-package-versions`命令 AWS CodeArtifact 获取存储库中软件包名称的所有版本的列表。

```
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)。

 您可以使用 `--max-results` 和 `--next-token` 参数对来自 `list-package-versions` 的响应进行分页。对于 `--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 *scope*) 中的 npm 程序包版本，请使用 `--namespace` 选项。`--namespace` 选项的值不得包括前导 `@`。要搜索命名空间`@types`，请将值设置为*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` 可以根据发布时间按降序排列输出版本（最先列出最近发布的版本）。使用值为 `PUBLISHED_TIME` 的 `--sort-by` 参数，如下所示。

```
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>

*资产*是存储在其中与软件包版本关联的单个文件（例如 npm `.tgz` 文件或 Maven POM 或 JAR 文件）。 CodeArtifact 您可以使用 `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>

*资产*是存储在其中与软件包版本关联的单个文件（例如 npm `.tgz` 文件或 Maven POM 或 JAR 文件）。 CodeArtifact 您可以使用 `get-package-version-assets command` 下载程序包资产。这样您就可以取回资产，而无需使用程序包管理器客户端（如 `npm` 或 `pip`）。要下载资产，必须提供可使用 `list-package-version-assets` 命令获取的资产名称，有关更多信息，请参阅[列出程序包版本资产](list-assets.md)。使用您指定的文件名将资源下载到本地存储。

以下示例从 Maven 包中下载*com.google.guava:guava*带有版本*27.1-jre*的*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` 权限，目标存储库必须具有 `CopyPackageVersions` 权限，这些权限分配给 IAM 账户或复制程序包的用户。以下策略是使用 `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>

使用中的`copy-package-versions`命令 CodeArtifact 将一个或多个软件包版本从源存储库复制到同一域中的目标存储库。以下示例会将名为 `my-package` 的 npm 程序包的 6.0.2 和 4.0.0 版本从 `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 软件开发工具包，请在`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>

如果您指定的版本在源存储库中不存在，则复制会失败。如果源存储库中存在某些版本，而有些版本不存在，则所有版本都将无法复制。在以下示例中，源存储库中存在 `array-unique` npm 程序包的版本 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` 的输出中列出。

在以下示例中，源存储库 `repo-1` 中存在 npm 程序包 `array-unique` 的两个版本。目标存储库 `dest-repo` 中也存在版本 0.2.1，但不存在版本 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` 命令。

**注意**  
必须使用 `copy-package-versions` 指定 `--versions` 或 `--version-revisions` 参数。不能同时指定两者。

仅在源存储库中存在程序包 `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
```

以下示例复制程序包 `my-package` 的两个版本，即 0.3.2 和 0.3.13。仅当在源存储库中，`my-package` 的版本 0.3.2 具有修订 `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 标签和 API。 CopyPackageVersions](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_repo` 中名为 `my-package` 的 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://console.aws.amazon.com/codesuite/codeartifact](https://console.aws.amazon.com/codesuite/codeartifact/home) /hom AWS CodeArtifact e 打开控制台。

1. 在导航窗格中，选择**存储库**。

1. 选择要从中删除程序包的**存储库**。

1. 选择要删除的**程序包**。

1. 选择**删除程序包**。

## 删除程序包版本 (AWS CLI)
<a name="delete-package-version-CLI"></a>

可以使用 `delete-package-versions` 命令一次删除一个或多个程序包版本。以下示例删除 `my_domain` 域的 `my_repo` 中名为 `my-package` 的 PyPI 程序包的版本 `4.0.0`、`4.0.1` 和 `5.0.0`：

```
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://console.aws.amazon.com/codesuite/codeartifact](https://console.aws.amazon.com/codesuite/codeartifact/home) /hom AWS CodeArtifact e 打开控制台。

1. 在导航窗格中，选择**存储库**。

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 和使用 `--name` 选项传递 Maven artifactID，从而指定要删除的程序包。例如，下面说明了如何删除 `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` 命令来查看有关程序包版本的详细信息。Package 版本详细信息是在软件包发布到时从包中提取的 CodeArtifact。不同程序包中的详细信息各不相同，且取决于程序包的格式以及作者向其中添加了多少信息。

 `describe-package-version` 命令输出中的大多数信息都取决于程序包的格式。例如，`describe-package-version` 从其 `package.json` 文件中提取 npm 程序包的信息。修订版由创建 CodeArtifact。有关更多信息，请参阅 [指定程序包版本修订](copy-package.md#specify-package-version-revision)。

 如果两个同名的程序包版本位于不同的命名空间中，则它们可以位于同一个存储库中。使用可选的 `--namespace` 参数来指定命名空间。有关更多信息，请参阅 [查看 npm 程序包版本详细信息](#describe-package-version-npm)或 [查看 Maven 程序包版本详细信息](#describe-package-version-maven)。

 以下示例返回有关 `my_repo` 存储库中名为 `pyhamcrest` 的 Python 程序包的版本 `1.9.0` 的详细信息。

```
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`例如，像 p [https://pyi 这样的 python 软件包。 org/project/rapyd-sdk/](https://pypi.org/project/rapyd-sdk/) 的许可证字段非常大，因此这些信息不会被处理。 CodeArtifact

## 查看 npm 程序包版本详细信息
<a name="describe-package-version-npm"></a>

要查看有关 npm 程序包版本的详细信息，请将 `--format` 选项的值设置为 **npm**。（可选）在 `--namespace` 选项中包括程序包版本命名空间 (npm *scope*)。`--namespace` 选项的值不得包括前导 `@`。要搜索命名空间`@types`，请将值设置为*types*。

下面返回有关 `@types` 作用域中名为 `webpack` 的 npm 程序包的版本 `4.41.5` 的详细信息。

```
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` 的 Maven 程序包的版本 `1.2` 的详细信息。

```
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` 存储库中名为 `my-package`、版本为 `4.41.5` 的 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 字段支持的值范围，请参阅 API 中的[PackageDependency](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html)数据类型。CodeArtifact *

## 查看程序包版本自述文件
<a name="view-package-readme"></a>

 某些程序包格式（例如 npm）包括一个 `README` 文件。使用 `get-package-version-readme` 来获取程序包版本的 `README` 文件。以下命令返回 `my_domain` 域的 `my_repo` 存储库中名为 `my-package`、版本为 `4.41.5` 的 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 程序包 `chalk` 版本 4.1.0 的状态设置为 `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 包`update-package-versions-status`进行调用的权限的 IAM 策略*chalk*将包含如下语句。

```
{
  "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` 参数。例如，要取消列出 `@nestjs/core` 的版本 8.0.0，请使用以下命令。

```
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调用 `update-package-versions-status` 时使用 `--namespace` 参数来指定 Maven 组 ID。例如，要存档 Maven 程序包 `org.apache.logging.log4j:log4j` 的版本 2.13.1，请使用以下命令。

```
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` 参数来传递一个或多个逗号分隔的程序包版本和程序包版本修订对。仅当程序包版本的当前修订与指定值相匹配时，才会更新程序包版本的状态。

**注意**  
使用 `--version-revisions` 参数时还必须定义 `—-versions` 参数。

```
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` 的同一次调用中指定的其他版本，并且不会更新其状态。这些版本也将包括在 `failedVersions` 映射中，且其 `errorCode` 为 `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)和[预期状态](#using-expected-status)部分中描述的 `--version-revisions ` 和 `--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。由于软件包提取设置为 “**阻止**”，因此版本 3.0 不会提取到您的 CodeArtifact 存储库中，也无法供与其连接的包管理员使用。

![\[一个简单的图形，显示了已阻止来自公有存储库的新外部程序包版本。\]](http://docs.aws.amazon.com/zh_cn/codeartifact/latest/ug/images/package-origin-controls-one.png)


**已为现有外部程序包发布内部程序包版本**

在此场景中，在外部的公有存储库中有一个名为 *packageB* 的程序包，已将该公有存储库连接到您的存储库。当连接到您的存储库的程序包管理器请求 *packageB* 时，从公有存储库中将程序包版本摄取到您的存储库中。由于这是 *packageB* 添加到存储库中的第一个程序包版本，因此程序包来源设置配置为**发布：阻止**和**上游：允许**。稍后，您尝试将具有相同程序包名称的版本发布到存储库。要么你不知道这个公共包并试图用同名发布一个不相关的包，要么你正在尝试发布一个经过补丁的版本，要么你正在尝试直接发布外部已经存在的确切包版本。 CodeArtifact 将拒绝您尝试发布的版本，但允许您显式覆盖拒绝并在必要时发布该版本。

在下图中，*RepoA* 是您的 CodeArtifact 存储库，它与公共存储库有外部连接。您的存储库包含从公有存储库中摄取的版本 3.0。您想将版本 1.1 发布到您的存储库。通常，您可以将版本 1.2 发布到 *repoA*，但是由于发布设置为**阻止**，因此无法发布版本 1.2。

![\[一个简单的图形，显示了已阻止来自公有存储库的新外部程序包版本。\]](http://docs.aws.amazon.com/zh_cn/codeartifact/latest/ug/images/package-origin-controls-two.png)


**发布现有外部程序包的已修补程序包版本**

在此场景中，在外部的公有存储库中有一个名为 *packageB* 的程序包，已将该公有存储库连接到您的存储库。当连接到您的存储库的程序包管理器请求 *packageB* 时，从公有存储库中将程序包版本摄取到您的存储库中。由于这是 *packageB* 添加到存储库中的第一个程序包版本，因此程序包来源设置配置为**发布：阻止**和**上游：允许**。您的团队确定需要将此程序包的已修补程序包版本发布到存储库。为了能够直接发布程序包版本，您的团队将程序包来源控制设置更改为**发布：允许**和**上游：阻止**。此程序包的版本现在可以直接发布到您的存储库并从公有存储库中摄取。在您的团队发布已修补的程序包版本后，您的团队会将程序包来源设置恢复为**发布：阻止**和**上游：允许**。

## 程序包来源控制设置
<a name="package-origin-control-settings"></a>

使用程序包来源控制，您可以配置将程序包版本添加到存储库的方式。以下列表包括可用的程序包来源控制设置和值。

**注意**  
对程序包组配置来源控制时，可用的设置和值会有所不同。有关更多信息，请参阅 [程序包组来源控制](package-group-origin-controls.md)。

**发布**

此设置配置了是否可以使用程序包管理器或类似工具将程序包版本直接发布到存储库。
+ **允许**：可以直接发布程序包版本。
+ **阻止**：不可以直接发布程序包版本。

**上游**

此设置配置了在程序包管理器发出请求时，是从外部的公有存储库中摄取程序包版本，还是在上游存储库中保留程序包版本。
+ **允许**：任何软件包版本都可以从配置为上游 CodeArtifact 存储库的其他存储库中保留，也可以通过外部连接从公共来源获取。
+ **BLOCK**：Package 版本不能从配置为上游存储 CodeArtifact 库的其他存储库中保留，也不能从具有外部连接的公共来源获取。

## 默认程序包来源控制设置
<a name="default-package-origin-control-settings"></a>

默认程序包来源控制设置是根据程序包的关联程序包组的来源控制设置进行配置的。有关程序包组和程序包组来源控制的更多信息，请参阅[在 CodeArtifact 中使用程序包组](package-groups.md)和[程序包组来源控制](package-group-origin-controls.md)。

如果程序包与程序包组关联，且每种限制类型的限制设置均为 `ALLOW`，则程序包的默认程序包来源控制将基于该程序包第一个版本添加到存储库中的方式。
+ 如果第一个程序包版本由程序包管理器直接发布，则设置将为**发布：允许**和**上游：阻止**。
+ 如果第一个程序包版本是从公有来源摄取，则设置将为**发布：阻止**和**上游：允许**。

**注意**  
2022 年 5 月左右之前存在于 CodeArtifact 存储库中的软件包的默认源控制为 “**发布：允许**” 和 “**上游：允许**”。必须手动为此类程序包设置程序包来源控制。从那时起，新的程序包开始采用当前的默认值，并于 2022 年 7 月 14 日推出该功能时开始强制执行。有关设置程序包来源控制的更多信息，请参阅[编辑程序包来源控制](#edit-package-origin-controls)。

否则，如果程序包与至少有一个限制设置设为 `BLOCK` 或 `ALLOW_SPECIFIC_REPOSITORIES` 的程序包组关联，则该程序包的默认来源控制设置将设为**发布：允许**和**上游：允许**。

## 程序包来源控制如何与程序包组来源控制交互
<a name="package-origin-controls-interaction-package-groups"></a>

由于程序包具有来源控制设置，其关联的程序包组也具有来源控制设置，因此了解这两种不同设置的彼此交互方式非常重要。

这两个设置之间的交互是：`BLOCK` 的设置始终优于 `ALLOW` 的设置。下表列出了一些示例配置及其有效的来源控制设置。


| 程序包来源控制设置 | 程序包组来源控制设置 | 有效的来源控制设置 | 
| --- | --- | --- | 
| 发布：允许上游：允许 | 发布：允许上游：允许 | 发布：允许上游：允许 | 
| 发布：阻止上游：允许 | 发布：允许上游：允许 | 发布：阻止上游：允许 | 
| 发布：允许上游：允许 | 发布：允许上游：阻止 | 发布：允许上游：阻止 | 

这意味着，如果一个程序包的来源设置设为**发布：允许**和**上游：允许**，那么它实际上是在遵循关联程序包组的来源控制设置。

## 编辑程序包来源控制
<a name="edit-package-origin-controls"></a>

根据程序包的第一个程序包版本添加到存储库的方式来自动配置程序包来源控制，有关更多信息，请参阅[默认程序包来源控制设置](#default-package-origin-control-settings)。要为 CodeArtifact 存储库中的软件包添加或编辑包源控件，请执行以下过程中的步骤。

**添加或编辑程序包来源控制（控制台）**

1. 在 [https://console.aws.amazon.com/codesuite/codeartifact](https://console.aws.amazon.com/codesuite/codeartifact/home) /hom AWS CodeArtifact e 打开控制台。

1. 在导航窗格中，选择**存储库**，然后选择包含了待编辑程序包的存储库。

1. 在**程序包**表中，搜索并选择要编辑的程序包。

1. 在程序包摘要页面的**来源控制**中，选择**编辑**。

1. 在**编辑来源控制**中，选择要为此程序包设置的程序包来源控制。必须同时设置两个程序包来源控制设置（“发布”和“上游”）。
   + 要允许直接发布程序包版本，请在**发布**中选择**允许**。要阻止发布程序包版本，请选择**阻止**。
   + 要允许从外部存储库摄取程序包和从上游存储库提取程序包，请在**上游来源**中选择**允许**。要阻止所有从外部存储库和上游存储库进行的程序包版本摄取和提取，请选择**阻止**。

**添加或编辑程序包来源控制 (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*替换为要更新的软件包的名称。
   + *BLOCK*用你想要的包裹来源控制设置替换*ALLOW*和。

   ```
   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` 上的程序包来源控制设置为**发布：允许**和**上游：允许**。如果存在`com.mycompany.mypackage:1.0`于上游存储库或 Maven Central 中，则 CodeArtifact 会拒绝任何向其发布的尝试，并出现 409 冲突错误。`myrepo`您仍然可以发布另一个版本，例如 `com.mycompany.mypackage:1.1`。

1. `com.mycompany.mypackage` 上的程序包来源控制设置为**发布：允许**和**上游：阻止**。您可以将 `com.mycompany.mypackage` 的任何版本发布到由于无法访问程序包版本而尚不存在该版本的存储库中。

1. `com.mycompany.mypackage` 上的程序包来源控制设置为**发布：阻止**和**上游：允许**。您不能直接将任何程序包版本发布到您的存储库。