亚马逊 CodeCatalyst 不再向新买家开放。现有客户可以继续正常使用该服务。有关更多信息，请参阅 [如何从中迁移 CodeCatalyst](migration.md)。

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

# 将程序包存储库连接到工作流
<a name="workflows-packages"></a>

软件*包*是一个包含安装软件和解决任何依赖关系所需的软件和元数据的捆绑包。 CodeCatalyst 支持 npm 包格式。

程序包中包括：
+ 一个名称（例如，`webpack` 是一个流行的 npm 程序包的名称）
+ 一个可选的[命名空间](packages-concepts.md#packages-concepts-package-namespaces)（例如，`@types/node` 中的 `@types`）
+ 一组[版本](packages-concepts.md#packages-concepts-package-versions)（例如，`1.0.0`、`1.0.1`、`1.0.2`）
+ 程序包级别的元数据（例如 npm dist 标签）

在中 CodeCatalyst，您可以将包发布到工作流程中的软件包存储库并使用来自软件 CodeCatalyst 包存储库的包。您可以使用 CodeCatalyst包存储库配置构建或测试操作，以自动配置操作的 npm 客户端，使其从指定的存储库中推送和拉取软件包。

有关程序包的更多信息，请参阅[在中发布和共享软件包 CodeCatalyst](packages.md)。

**注意**  
目前，生成和测试操作支持 CodeCatalyst 软件包存储库。

**Topics**
+ [教程：从程序包存储库中拉取](packages-tutorial.md)
+ [在工作流程中指定 CodeCatalyst 软件包存储库](workflows-package-specify-action.md)
+ [在工作流操作中使用授权令牌](workflows-package-export-token.md)
+ [示例：工作流中的程序包存储库](workflows-working-packages-ex.md)

# 教程：从程序包存储库中拉取
<a name="packages-tutorial"></a>

在本教程中，您将学习如何创建工作流程，该工作流程运行依赖项从[CodeCatalyst 包存储库](packages-concepts.md#packages-concepts-repository)中提取的应用程序。该应用程序是一个简单的 Node.js 应用程序，可在日志中输出 “Hello World” 消息。 CodeCatalyst 该应用程序具有一个依赖项：[lodash](https://www.npmjs.com/package/lodash) npm 程序包。`lodash` 程序包用于将 `hello-world` 字符串转换为 `Hello World`。您将使用此程序包的 4.17.20 版本。

设置应用程序和工作流程后，您可以配置 CodeCatalyst 为阻止其他版本`lodash`从公共外部注册表 ([npmj](https://www.npmjs.com/) s.com) 导入 CodeCatalyst 软件包存储库。之后，您可以测试是否已成功阻止其他版本的 `lodash`。

在本教程结束时，您应该对工作流程如何与内部和外部 CodeCatalyst的软件包存储库进行交互以检索软件包有了很好的了解。你还应该了解 npm、你的包存储库、你的工作流程和你的应用程序`package.json`文件之间发生的 behind-the-scenes交互。

**Topics**
+ [先决条件](#packages-tutorial-prereqs)
+ [步骤 1：创建源存储库](#packages-tutorial-source-repo)
+ [步骤 2：创建 CodeCatalyst 和网关软件包存储库](#packages-tutorial-package-repo)
+ [步骤 3：创建“Hello World”应用程序](#packages-tutorial-create-app)
+ [步骤 4：创建运行“Hello World”的工作流](#packages-tutorial-create-workflow)
+ [步骤 5：验证工作流](#packages-tutorial-verify)
+ [步骤 6：阻止来自 npmjs.com 的导入](#packages-tutorial-block)
+ [步骤 7：测试阻止功能](#packages-tutorial-test-block)
+ [清理](#packages-tutorial-cleanup)

## 先决条件
<a name="packages-tutorial-prereqs"></a>

开始前的准备工作：
+ 你需要一个 CodeCatalyst **空间**。有关更多信息，请参阅 [创建空间](spaces-create.md)。
+ 在你的 CodeCatalyst 空间里，你需要一个名为：

  ```
  codecatalyst-package-project
  ```

  使用**从头开始**选项来创建此项目。

  有关更多信息，请参阅 [在 Amazon 中创建一个空项目 CodeCatalyst](projects-create.md#projects-create-empty)。

## 步骤 1：创建源存储库
<a name="packages-tutorial-source-repo"></a>

在此步骤中，您将在中创建源存储库 CodeCatalyst。此存储库将存储教程的源文件，例如 `index.js` 和 `package.json` 文件。

有关源存储库的更多信息，请参阅[创建源存储库](source-repositories-create.md)。

**创建源存储库**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 导航到您的项目 `codecatalyst-package-project`。

1. 在导航窗格中，选择**代码**，然后选择**源存储库**。

1. 选择**添加存储库**，然后选择**创建存储库**。

1. 在**存储库名称**中，输入：

   ```
   hello-world-app
   ```

1. 选择**创建**。

## 步骤 2：创建 CodeCatalyst 和网关软件包存储库
<a name="packages-tutorial-package-repo"></a>

在此步骤中，您将在 CodeCatalyst 项目中创建包存储库，并将其连接到网关存储库（也包括在您的 CodeCatalyst 项目中）。稍后，您将本教程中的依赖项 `lodash` 从 npmjs.com 导入到这两个存储库中。

网关存储库是将你的软件包存储库连接到公共 npmjs.co CodeCatalyst m 的 “粘合剂”。

有关程序包存储库的更多信息，请参阅[在中发布和共享软件包 CodeCatalyst](packages.md)。

**注意**  
本教程使用*CodeCatalyst 软件包存储库*和*网关存储库*这两个术语来指您在以下过程中创建 CodeCatalyst 的两个存储库。

**创建 CodeCatalyst 软件包和网关存储库**

1. 在导航窗格中，选择**程序包**。

1. 选择**创建程序包存储库**。

1. 在**存储库名称**中，输入：

   ```
   codecatalyst-package-repository
   ```

1. 选择 **\$1 选择上游存储库**。

1. 选择**网关存储库**。

1. 在**npm-public-registry-gateway**框中，选择**创建**。

1. 选定**选择**。

1. 选择**创建**。

   CodeCatalyst 创建名为的软件包存储库`codecatalyst-package-repository`，该存储库已连接到网关存储库。网关存储库将连接到 npmjs.com 注册表。

## 步骤 3：创建“Hello World”应用程序
<a name="packages-tutorial-create-app"></a>

在此步骤中，您将创建一个 “Hello World” Node.js 应用程序并将其依赖关系 (`lodash`) 导入网关和 CodeCatalyst 软件包存储库。

要创建该应用程序，您需要一台安装了 Node.js 和相关 `npm` 客户端的开发机器。

本教程假设您将使用 CodeCatalyst 开发环境作为开发机器。尽管你不必使用 CodeCatalyst 开发环境，但还是推荐使用它，因为它提供了一个干净的工作环境，`npm`预装了 Node.js，而且在你完成本教程后很容易删除。有关 CodeCatalyst 开发环境的更多信息，请参阅[创建开发环境](devenvironment-create.md)。

按照以下说明启动 CodeCatalyst 开发环境并使用它来创建 “Hello World” 应用程序。

**启动 CodeCatalyst 开发环境**

1. 在导航窗格中，选择**代码**，然后选择**开发环境**。

1. 在顶部附近，选择**创建开发环境**，然后选择 **AWS Cloud9 (在浏览器中)**。

1. 确保**存储库**设置为 `hello-world-app`，并且**现有分支**设置为 `main`。选择**创建**。

   您的开发环境将在新的浏览器标签页中启动，并且您的存储库（`hello-world-app`）将克隆到其中。

1. 让两个 CodeCatalyst 浏览器选项卡保持打开状态，然后转到下一个步骤。

**创建“Hello World”Node.js 应用程序**

1. 转到您的开发环境。

1. 在终端提示符下，更改为 `hello-world-app` 源存储库根目录：

   ```
   cd hello-world-app
   ```

1. 初始化一个 Node.js 项目：

   ```
   npm init -y
   ```

   初始化过程将在 `hello-world-app` 的根目录中创建一个 `package.json` 文件。

1. 将开发环境中的 npm 客户端连接到你的 CodeCatalyst 包存储库：

   1. 切换到 CodeCatalyst 控制台。

   1. 在导航窗格中，选择**程序包**。

   1. 选择 `codecatalyst-package-repository`。

   1. 选择**连接到存储库**。

   1. 选择**创建令牌**。这将为您创建个人访问令牌（PAT）。

   1. 选择**复制**以复制命令。

   1. 切换到您的开发环境。

   1. 确保您位于 `hello-world-app` 目录中。

   1. 粘贴命令。其内容与以下内容类似：

      ```
      npm set registry=https://packages.us-west-2.codecatalyst.aws/npm/ExampleCompany/codecatalyst-package-project/codecatalyst-package-repository/ --location project
      npm set //packages.us-west-2.codecatalyst.aws/npm/ExampleCompany/codecatalyst-package-project/hello-world-app/:_authToken=username:token-secret
      ```

1. 导入 `lodash` 版本 4.17.20：

   ```
   npm install lodash@v4.17.20 --save --save-exact
   ```

   npm 按以下顺序在以下位置查找 `lodash` 版本 4.17.20：
   + 在开发环境中。它在该位置找不到此版本。
   + 在 CodeCatalyst 软件包存储库中。它在该位置找不到此版本。
   + 在网关存储库中。它在该位置找不到此版本。
   + 在 npmjs.com 中。它在该位置找到此版本。

   npm 导`lodash`入到网关存储库、 CodeCatalyst 软件包存储库和开发环境中。
**注意**  
如果你在第 4 步中没有将 npm 客户端连接到你的 CodeCatalyst 软件包存储库，那么 npm 本来可以`lodash`直接从 npmjs.com 中提取并且不会将包导入到任何一个存储库中。

   npm 还使用 `lodash` 依赖项更新 `package.json` 文件，并创建一个包含 `lodash` 其所有依赖项的 `node_modules` 目录。

1. 测试是否已将 `lodash` 成功导入开发环境中。输入：

   ```
   npm list
   ```

   这将显示以下消息，表示已成功导入：

   ```
   `-- lodash@4.17.20
   ```

1. （可选）打开`hello-world-app/package.json`并验证中的行是否***red bold***已添加：

   ```
   {
     "name": "hello-world-app",
     "version": "1.0.0",
     "description": "",
     "main": "index.js",
     "scripts": {
       "test": "echo \"Error: no test specified\" && exit 1"
     },
     "keywords": [],
     "author": "",
     "license": "ISC",
     dependencies": {
       "lodash": "4.17.20"
     }
   }
   ```

1. 在 `/hello-world-app` 中，创建一个名为 `index.js` 的包含以下内容的文件：
**提示**  
您可以使用开发环境中的侧面导航来创建此文件。

   ```
   // Importing lodash library
   const _ = require('lodash');
   
   // Input string
   const inputString = 'hello-world';
   
   // Transforming the string using lodash
   const transformedString = _.startCase(inputString.replace('-', ' '));
   
   // Outputting the transformed string to the console
   console.log(transformedString);
   ```

**测试 “lodash” 是否已导入到您的网关和 CodeCatalyst 软件包存储库中**

1. 切换到 CodeCatalyst 控制台。

1. 在导航窗格中，选择**程序包**。

1. 选择 **npm-public-registry-gateway**。

1. 确保已显示 `lodash`。**最新版本**列指示 `4.17.20`。

1. 对 `codecatalyst-package-repository` 重复此过程。您可能需要刷新浏览器窗口才能看到已导入的程序包。

**在开发环境中测试“Hello World”**

1. 切换到您的开发环境。

1. 确保您仍在 `hello-world-app` 目录中，然后运行应用程序：

   ```
   node index.js
   ```

   这将显示 `Hello World` 消息。Node.js 使用您在上一步中下载到开发环境的 `lodash` 程序包运行应用程序。

**忽略“node\$1modules”目录并提交“Hello World”**

1. 忽略 `node_modules` 目录。输入：

   ```
   echo "node_modules/" >> .gitignore
   ```

   最佳实践是避免提交此目录。此外，提交此目录会干扰本教程中的后续步骤。

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "add the Hello World application"
   git push
   ```

   “Hello World”应用程序和项目文件将添加到源存储库中。

## 步骤 4：创建运行“Hello World”的工作流
<a name="packages-tutorial-create-workflow"></a>

在此步骤中，您将创建一个使用 `lodash` 依赖项运行“Hello World”应用程序的工作流。该工作流包含一个名为 `RunHelloWorldApp` 的*操作*或任务。`RunHelloWorldApp` 操作包括以下值得注意的命令和部分：
+ **`Packages`**

  此部分指出了操作在运行时必须连接到的 CodeCatalyst 包存储库的名称`npm install`。
+ **`- Run: npm install`** 

  此命令告知 npm 安装 `package.json` 文件中指定的依赖项。`package.json` 文件中指定的唯一依赖项是 `lodash`。npm 会在以下位置查找 `lodash`：
  + 在运行该操作的 Docker 映像中。它在该位置找不到此版本。
  + 在 CodeCatalyst 软件包存储库中。它在该位置找到此版本。

  npm 在找到 `lodash` 后，会将它导入到运行该操作的 Docker 映像中。
+ **`- Run: npm list`**

  此命令会打印出已下载到运行该操作的 Docker 映像的 `lodash` 的版本。
+ **`- Run: node index.js`**

  此命令使用 `package.json` 文件中指定的依赖项运行“Hello World”应用程序。

请注意，`RunHelloWorldApp` 操作是一个构建操作，如工作流顶部附近的 `aws/build@v1` 标识符所示。有关构建操作的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。

按照以下说明创建工作流程，从 CodeCatalyst 软件包存储库中提取`lodash`依赖关系，然后运行 “Hello World” 应用程序。

**创建工作流**

1. 切换到 CodeCatalyst 控制台。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择**创建工作流**。

1. 对于**源存储库**，选择 `hello-world-app`。

1. 对于**分支**，选择 `main`。

   这将在选定的源存储库和分支中创建工作流定义文件。

1. 选择**创建**。

1. 在顶部附近选择 **YAML**。

1. 删除 YAML 示例代码。

1. 添加以下 YAML 代码：

   ```
   Name: codecatalyst-package-workflow
   SchemaVersion: "1.0"
   
   # Required - Define action configurations.
   Actions:
     RunHelloWorldApp:
       # Identifies the action. Do not modify this value.
       Identifier: aws/build@v1
       Compute:
         Type: Lambda
       Inputs:
         Sources:
           - WorkflowSource # This specifies your source repository. 
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm list
           - Run: node index.js
         Container: # This specifies the Docker image that runs the action.
           Registry: CODECATALYST
           Image: CodeCatalystLinuxLambda_x86_64:2024_03
       Packages:
         NpmConfiguration:
           PackageRegistries:
             - PackagesRepository: codecatalyst-package-repository
   ```

   在前面的代码中，*codecatalyst-package-repository*替换为您在中创建的 CodeCatalyst 软件包存储库的名称[步骤 2：创建 CodeCatalyst 和网关软件包存储库](#packages-tutorial-package-repo)。

   有关此文件中的属性的信息，请参阅[构建和测试操作 YAML](build-action-ref.md)。

1. （可选）选择**验证**，确保 YAML 代码在提交之前有效。

1. 选择**提交**。

1. 在**提交工作流**对话框中，输入以下内容：

   1. 对于**工作流文件名**，保留默认值 `codecatalyst-package-workflow`。

   1. 对于**提交消息**，输入：

      ```
      add initial workflow file
      ```

   1. 对于**存储库**，选择 **hello-world-app**。

   1. 对于**分支名称**，选择**主**。

   1. 选择**提交**。

   现在，您已创建工作流。

**运行工作流**

1. 在您刚刚创建的工作流（`codecatalyst-package-workflow`）旁边，选择**操作**，然后选择**运行**。

   工作流运行将开始。

1. 在右侧顶部的绿色通知中，选择运行的链接。该链接看起来类似于 `View Run-1234`。

   此时将出现一个工作流程图，显示谁启动了运行和**RunHelloWorldApp**操作。

1. 选择**RunHelloWorldApp**操作框以查看操作的进度。

1. 运行完成后，转至[步骤 5：验证工作流](#packages-tutorial-verify)。

## 步骤 5：验证工作流
<a name="packages-tutorial-verify"></a>

在此步骤中，您将验证工作流是否已使用其 `lodash` 依赖项成功运行“Hello World”应用程序。

**验证“Hello World”应用程序是否已使用其依赖项运行**

1. 在工作流程图中，选中该**RunHelloWorldApp**复选框。

   这将显示日志消息列表。

1. 展开 `node index.js` 日志消息。

   这将显示以下消息：

   ```
   [Container] 2024/04/24 21:15:41.545650 Running command node index.js
   Hello World
   ```

   显示 `Hello Word`（而不是 `hello-world`）指明已成功使用 `lodash` 依赖项。

1. 展开 `npm list` 日志。

   这将显示一条与以下内容类似的消息：

   ```
   └── lodash@4.17.20
   ```

   此消息指示 `lodash` 版本 4.17.20 已下载到运行工作流操作的 Docker 映像。

## 步骤 6：阻止来自 npmjs.com 的导入
<a name="packages-tutorial-block"></a>

 现在 4.17.20 `lodash` 版本已存在于您的网关和 CodeCatalyst软件包存储库中，您可以阻止其他版本的导入。阻止可防止您意外导入可能包含恶意代码的更高（或更早）版本的 `lodash`。有关更多信息，请参阅[编辑程序包来源控制](package-origin-controls.md)和[依赖项替换攻击](package-origin-controls.md#dependency-substitution-attacks)。

按照以下说明操作，阻止将 `lodash` 导入到网关存储库中。当您在网关上阻止程序包时，它们也会在下游位置被阻止。

**阻止导入到网关存储库**

1. 在导航窗格中，选择**程序包**。

1. 选择 **npm-publish-registry-gateway**。

1. 选择 `lodash`。

1. 在顶部附近，选择**源控制**。

1. 在**上游**下，选择**阻止**。

1. 选择**保存**。

   现在，您已阻止从 npmjs.com 导入网关存储库（以及下游存储库和计算机）中。

## 步骤 7：测试阻止功能
<a name="packages-tutorial-test-block"></a>

在此部分中，您将验证您在 [步骤 6：阻止来自 npmjs.com 的导入](#packages-tutorial-block) 中设置的阻止是否有效。首先，将“Hello World”配置为 `lodash` 的请求版本 4.17.2**1**，而不是网关存储库中可用的版本，即 4.17.2**0**。然后，检查应用程序是否无法从 nmpjs.com 中拉取版本 4.17.21，这表示已成功阻止。作为最终测试，您需要解除阻止导入到网关存储库，并检查应用程序是否能成功拉取 `lodash` 的版本 4.17.21。

使用以下一组过程来测试阻止功能。

**开始前的准备工作**

1. 切换到您的开发环境。

1. 提取您之前使用 CodeCatalyst 控制台创建的`codecatalyst-package-workflow.yaml`文件：

   ```
   git pull
   ```

**将“Hello World”配置为“lodash”的请求版本 4.17.21**

1. 打开 `/hello-world-app/package.json`。

1. 将`lodash`版本更改为 4.17.21，如所示：***red bold***

   ```
   {
     "name": "hello-world-app",
     "version": "1.0.0",
     "description": "",
     "main": "index.js",
     "scripts": {
       "test": "echo \"Error: no test specified\" && exit 1"
     },
     "keywords": [],
     "author": "",
     "license": "ISC",
     "dependencies": {
       "lodash": "4.17.21"
     }
   }
   ```

   现在，`package.json`文件中的版本 (4.17.21) 与网关和 CodeCatalyst 软件包存储库中的版本 (4.17.20) 不匹配。

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "update package.json to use lodash 4.17.21"
   git push
   ```

**测试“Hello World”是否无法拉取“lodash”的版本 4.17.21**

1. 在版本不匹配的情况下运行工作流：

   1. 切换到 CodeCatalyst 控制台。

   1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

   1. 在 `codecatalyst-package-workflow` 旁边，选择**操作**，然后选择**运行**。

      npm 会在 `package.json` 中查找依赖项，并看到“Hello World”需要 `lodash` 的版本 4.17.21。npm 按以下顺序在以下位置查找依赖项：
      + 在运行该操作的 Docker 映像中。它在该位置找不到此版本。
      + 在 CodeCatalyst 软件包存储库中。它在该位置找不到此版本。
      + 在网关存储库中。它在该位置找不到此版本。
      + 在 npmjs.com 中。它在该位置找到此版本。

      npm 在 npmjs.com 中找到版本 4.17.21 后，会尝试将它导入网关存储库中，但由于您将网关设置为阻止导入 `lodash`，因此无法执行导入。

      由于无法执行导入，因此工作流将失败。

1. 验证工作流是否已失败：

   1. 在右侧顶部的绿色通知中，选择运行的链接。该链接看起来类似于 `View Run-2345`。

   1. 在工作流程图中，选中该**RunHelloWorldApp**复选框。

   1. 展开 `npm install` 日志消息。

      这将显示以下消息：

      ```
      [Container] 2024/04/25 17:20:34.995591 Running command npm install
      npm ERR! code ETARGET
      npm ERR! notarget No matching version found for lodash@4.17.21.
      npm ERR! notarget In most cases you or one of your dependencies are requesting
      npm ERR! notarget a package version that doesn't exist.
      
      npm ERR! A complete log of this run can be found in: /tmp/.npm/_logs/2024-05-08T22_03_26_493Z-debug-0.log
      ```

      该错误表明找不到版本 4.17.21。这是预期结果，因为您已阻止导入。

**解除阻止来自 npmjs.com 的导入**

1. 在导航窗格中，选择**程序包**。

1. 选择 **npm-publish-registry-gateway**。

1. 选择 `lodash`。

1. 在顶部附近，选择**源控制**。

1. 在**上游**下，选择**允许**。

1. 选择**保存**。

   您现在已解除阻止导入 `lodash`。

   您的工作流现在可以导入 `lodash` 的版本 4.17.21。

**测试是否已解除阻止来自 npmjs.com 的导入**

1. 再次运行工作流。这次工作流应成功，因为现在应已能够导入版本 4.17.21。要再次运行工作流，请执行以下操作：

   1. 选择 **CI/CD**，然后选择**工作流**。

   1. 在 `codecatalyst-package-workflow` 旁边，选择**操作**，然后选择**运行**。

   1. 在右侧顶部的绿色通知中，选择运行的链接。该链接看起来类似于 `View Run-3456`。

      此时将出现一个工作流程图，显示谁启动了运行和**RunHelloWorldApp**操作。

   1. 选择**RunHelloWorldApp**操作框以查看操作的进度。

   1. 展开 `npm list` 日志消息，验证是否显示与以下内容类似的消息：

      ```
      └── lodash@4.17.21
      ```

      此消息指示已下载 `lodash` 版本 4.17.21。

1. 验证版本 4.17.21 是否已导入到您的 CodeCatalyst 和网关存储库中：

   1. 在导航窗格中，选择**程序包**。

   1. 选择 **npm-public-registry-gateway**。

   1. 查找 `lodash` 并确保版本为 `4.17.21`。
**注意**  
虽然此页面上未列出版本 4.17.20，但您可以通过选择 `lodash`，然后选择顶部附近的**版本**来找到该版本。

   1. 重复这些步骤以检查是否已将版本 4.17.21 导入 `codecatalyst-package-repository`。

## 清理
<a name="packages-tutorial-cleanup"></a>

清理本教程中使用的文件和服务以免被收取费用。

**清理程序包教程**

1. 删除 `codecatalyst-package-project`：

   1. 在 CodeCatalyst 控制台中，如果您尚未进入该`codecatalyst-package-project`项目，请转到该项目。

   1. 在导航窗格中，选择**项目设置**。

   1. 选择**删除项目**，输入 **delete**，然后选择**删除项目**。

      CodeCatalyst 删除所有项目资源，包括源存储库、网关存储库和 CodeCatalyst包存储库。也将删除开发环境。

1. 删除 PAT 令牌：

   1. 在右侧选择您的用户名，然后选择**我的设置**。

   1. 在**个人访问令牌**下，选择您在本教程中创建的令牌，然后选择**删除**。

在本教程中，您学习了如何创建一个工作流程，该工作流程运行从 CodeCatalyst 包存储库中提取其依赖关系的应用程序。您还学习了如何阻止和取消阻止软件包进入网关和 CodeCatalyst 软件包存储库。

# 在工作流程中指定 CodeCatalyst 软件包存储库
<a name="workflows-package-specify-action"></a>

在中 CodeCatalyst，您可以将 CodeCatalyst 包存储库添加到工作流程中的生成和测试操作中。您的程序包存储库必须配置为程序包格式，例如 npm。您也可以为选定的程序包存储库包括一系列范围。

按照以下说明指定要用于工作流操作的程序包配置。

------
#### [ Visual ]

**指定操作将使用的程序包配置（可视化编辑器）**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择**可视化**。

1. 在工作流图表中，对要配置的程序包存储库选择**构建**或**测试**操作。

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

1. 从**添加配置**下拉菜单中，选择要用于工作流操作的程序包配置。

1. 选择**添加程序包存储库**。

1. 在 P **ackage 存储库**下拉菜单中，指定您希望该操作使用的 CodeCatalyst *包存储库*的名称。

   有关程序包存储库的更多信息，请参阅[程序包存储库](packages-concepts.md#packages-concepts-repository)。

1. （可选）在**范围 – 可选**中，指定您要在程序包注册表中定义的*范围*序列。

   定义范围时，将指定的程序包存储库配置为所有列出范围的注册表。如果通过 npm 客户端请求具有范围的程序包，此程序包将使用该存储库而不是默认存储库。每个范围名称必须以“@”为前缀。

   如果省略 `Scopes`，则将指定的程序包存储库配置为该操作使用的所有程序包的默认注册表。

   有关范围的更多信息，请参阅[程序包命名空间](packages-concepts.md#packages-concepts-package-namespaces)和[范围限定的程序包](https://docs.npmjs.com/cli/v10/using-npm/scope)。

1. 选择**添加**。

1. （可选）选择**验证**，在提交之前验证工作流的 YAML 代码。

1. 选择**提交**，输入提交消息，然后再次选择**提交**。

------
#### [ YAML ]

**指定操作将使用的程序包配置（YAML 编辑器）**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在**构建**或**测试**操作中，添加类似于以下内容的代码：

   ```
   action-name:
    Configuration:
       Packages:
           NpmConfiguration:
             PackageRegistries:
               - PackagesRepository: package-repository
                 Scopes:
                   - "@scope"
   ```

   有关更多信息，请参阅[构建和测试操作 YAML](build-action-ref.md) 中对相应操作的 `Packages` 属性的说明。

1. （可选）选择**验证**，在提交之前验证工作流的 YAML 代码。

1. 选择**提交**，输入提交消息，然后再次选择**提交**。

------

# 在工作流操作中使用授权令牌
<a name="workflows-package-export-token"></a>

您可以使用工作流操作提供的令牌手动配置包管理器以使用 CodeCatalyst 包存储库进行身份验证。 CodeCatalyst 使此令牌可用作环境变量，供您在操作中引用。


| 环境变量 | 值 | 
| --- | --- | 
|  CATALYST\$1MACHINE\$1RESOURCE\$1NAME  |  授权令牌的用户身份。  | 
|  CATALYST\$1PACKAGES\$1AUTHORIZATION\$1TOKEN  |  授权令牌的值。  | 

**注意**  
请注意，只有在您将操作配置为导出授权令牌后，才会填充这些环境变量。

按照以下说明在工作流操作中使用授权令牌。

------
#### [ Visual ]

**将导出的授权令牌与操作配合使用（可视化编辑器）**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择**可视化**。

1. 在工作流图表中，对要配置的程序包存储库选择**构建**或**测试**操作。

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

1. 开启**导出授权令牌**。

------
#### [ YAML ]

**将导出的授权令牌与操作配合使用（YAML 编辑器）**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在**构建**或**测试**操作中，添加类似于以下内容的代码：

   ```
   Actions:
     action-name:
       Packages:
         ExportAuthorizationToken: true
   ```

   您可以在 YAML 的 `Steps` 部分中引用 `$CATALYST_MACHINE_RESOURCE_NAME` 和 `$CATALYST_PACKAGES_AUTHORIZATION_TOKEN` 环境变量。有关更多信息，请参阅[示例：手动配置`pip`为使用进行身份验证 CodeCatalyst](workflows-working-packages-ex.md#workflows-working-packages-pypi-token)。

1. （可选）选择**验证**，在提交之前验证工作流的 YAML 代码。

1. 选择**提交**，输入提交消息，然后再次选择**提交**。

------

# 示例：工作流中的程序包存储库
<a name="workflows-working-packages-ex"></a>

以下示例演示了如何在工作流定义文件中引用程序包。

**Topics**
+ [示例：使用 `NpmConfiguration` 定义程序包](#workflows-working-packages-ex-basic)
+ [示例：覆盖默认注册表](#workflows-working-packages-ex-overriding-registry)
+ [示例：覆盖程序包注册表中的范围](#workflows-working-packages-ex-overriding-scopes)
+ [示例：手动配置`pip`为使用进行身份验证 CodeCatalyst](#workflows-working-packages-pypi-token)

## 示例：使用 `NpmConfiguration` 定义程序包
<a name="workflows-working-packages-ex-basic"></a>

以下示例展示了如何使用 `NpmConfiguration` 在工作流定义文件中定义程序包。

```
Actions:
  Build:
  Identifier: aws/build-beta@v1
  Configuration:
    Packages:
        NpmConfiguration:
          PackageRegistries:
            - PackagesRepository: main-repo
            - PackagesRepository: scoped-repo
              Scopes:
                - "@scope1"
```

此示例如下所示配置 npm 客户端：

```
default: main-repo
@scope1: scoped-repo
```

在此示例中，定义了两个存储库。默认注册表设置为 `main-repo`，在定义时没有范围。范围 `@scope1` 在 `PackageRegistries` 中为 `scoped-repo` 配置。

## 示例：覆盖默认注册表
<a name="workflows-working-packages-ex-overriding-registry"></a>

以下示例演示了如何覆盖默认注册表。

```
NpmConfiguration:
  PackageRegistries:
    - PackagesRepository: my-repo-1
    - PackagesRepository: my-repo-2
    - PackagesRepository: my-repo-3
```

此示例如下所示配置 npm 客户端：

```
default: my-repo-3
```

如果您指定多个默认存储库，则优先使用最后一个存储库。在此示例中，列出的最后一个存储库是 `my-repo-3`，这意味着 npm 将连接到 `my-repo-3`。这会覆盖存储库 `my-repo-1` 和 `my-repo-2`。

## 示例：覆盖程序包注册表中的范围
<a name="workflows-working-packages-ex-overriding-scopes"></a>

以下示例展示了如何覆盖程序包注册表中的范围。

```
NpmConfiguration:
  PackageRegistries:
    - PackagesRepository: my-default-repo
    - PackagesRepository: my-repo-1
      Scopes:
        - "@scope1"
        - "@scope2"
    - PackagesRepository: my-repo-2
      Scopes:
        - "@scope2"
```

此示例如下所示配置 npm 客户端：

```
default: my-default-repo
@scope1: my-repo-1
@scope2: my-repo-2
```

如果您包含覆盖范围，则优先使用最后一个存储库。在本示例中，在 `PackageRegistries` 中最后一次配置范围 `@scope2` 是为 `my-repo-2` 配置的。这会覆盖为 `my-repo-1` 配置的范围 `@scope2`。

## 示例：手动配置`pip`为使用进行身份验证 CodeCatalyst
<a name="workflows-working-packages-pypi-token"></a>

以下示例向您展示了如何在生成操作中引用 CodeCatalyst 授权环境变量。

```
Actions:
  Build:
    Identifier: aws/build@v1.0.0
    Configuration:
      Steps:
        - Run: pip config set global.index-url https://$CATALYST_MACHINE_RESOURCE_NAME:$CATALYST_PACKAGES_AUTHORIZATION_TOKEN@codecatalyst.aws/pypi/my-space/my-project/my-repo/simple/
    Packages:
      ExportAuthorizationToken: true
```