

Amazon CodeCatalyst 不再向新客戶開放。現有客戶可以繼續正常使用該服務。如需詳細資訊，請參閱[如何從 CodeCatalyst 遷移](migration.md)。

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

# 在 CodeCatalyst 中發佈和共用軟體套件
<a name="packages"></a>

Amazon CodeCatalyst 包含全受管套件儲存庫服務，可讓您的開發團隊輕鬆安全地存放和共用用於應用程式開發的軟體套件。這些套件存放在套件儲存庫中，這些儲存庫是在 CodeCatalyst 中的專案中建立和組織。

單一套件儲存庫可以存放每個支援套件類型的套件。CodeCatalyst 支援下列套件格式：
+ npm
+ Maven
+ NuGet
+ Python

套件儲存庫中的套件可以在包含儲存庫的專案成員之間探索和共用。

若要將套件發佈至 ，並從儲存庫取用套件，請將套件管理員設定為使用儲存庫端點 (URL)。然後，您可以使用套件管理員將套件發佈至儲存庫。您可以使用套件管理員，例如 Maven、Gradle、npm、 yarn、nuget、dotnet、pip 和 Twine。

您也可以設定 CodeCatalyst 工作流程來使用 CodeCatalyst 套件儲存庫。如需在工作流程中使用套件的詳細資訊，請參閱 [將套件儲存庫連線至工作流程](workflows-packages.md)。

您可以將一個套件儲存庫中的套件新增為上游儲存庫，使其可供相同專案中的另一個儲存庫使用。上游儲存庫可用的所有套件版本也可供下游儲存庫使用。如需詳細資訊，請參閱[設定和使用上游儲存庫](packages-upstream-repositories.md)。

您可以建立稱為**閘道**的特殊儲存庫類型，讓開放原始碼套件可供 CodeCatalyst 儲存庫使用。串流至閘道儲存庫可讓您取用來自熱門公有儲存庫的套件，例如 npmjs.com 和 pypi.org，並自動將其快取至 CodeCatalyst 儲存庫。如需詳細資訊，請參閱[連線到公有外部儲存庫](packages-connect-external.md)。

**Topics**
+ [套件概念](packages-concepts.md)
+ [設定和使用套件儲存庫](packages-repositories.md)
+ [設定和使用上游儲存庫](packages-upstream-repositories.md)
+ [連線到公有外部儲存庫](packages-connect-external.md)
+ [發佈和修改套件](working-with-packages.md)
+ [使用 NPM](packages-npm.md)
+ [使用 Maven](packages-maven.md)
+ [使用 NuGet](packages-nuget.md)
+ [使用 Python](packages-python.md)
+ [套件的配額](packages-quotas.md)

# 套件概念
<a name="packages-concepts"></a>

以下是在 CodeCatalyst 中管理、發佈或取用套件時應注意的一些概念和術語。

## 套件
<a name="packages-concepts-packages"></a>

*套件*是一種套件，其中包含安裝軟體和解決任何相依性所需的軟體和中繼資料。CodeCatalyst 支援 npm 套件格式。

套件包含：
+ 名稱 （例如， `webpack` 是熱門 npm 套件的名稱）
+ 選用[的命名空間](#packages-concepts-package-namespaces) （例如，在 `@types`中`@types/node`)
+ 一組[版本](#packages-concepts-package-versions) （例如 、`1.0.0``1.0.1`、`1.0.2`)
+ 套件層級中繼資料 （例如 npm dist 標籤）

## 套件命名空間
<a name="packages-concepts-package-namespaces"></a>

有些套件格式支援階層式套件名稱，可將套件組織成邏輯群組，並協助避免名稱衝突。具有相同名稱的套件可以存放在不同的命名空間中。例如，npm 支援範圍，而 npm 套件的範圍`@types/node`為 `@types`，名稱為 `node`。`@types` 範圍內還有許多其他套件名稱。在 CodeCatalyst 中，範圍 (「類型」) 稱為套件命名空間，而名稱 (「節點」) 稱為套件名稱。對於 Maven 套件，套件命名空間對應至 Maven groupID。Maven 套件`org.apache.logging.log4j:log4j`的 groupID （套件命名空間） 為 `org.apache.logging.log4j`，而 artifactID （套件名稱） 為 `log4j`。Python 等某些套件格式不支援階層式名稱，其概念類似於 npm 範圍或 Maven groupID。如果您沒有將套件名稱分組的方法，可能更難避免名稱衝突。

## 套件版本
<a name="packages-concepts-package-versions"></a>

*套件版本*可識別套件的特定版本，例如 `@types/node@12.6.9`。版本編號格式和語意因不同的套件格式而異。例如，npm 套件版本必須符合[語意版本控制規格](https://semver.org/)。在 CodeCatalyst 中，套件版本包含版本識別符、package-version-level中繼資料和一組資產。

## 資產
<a name="packages-concepts-assets"></a>

*資產*是存放在 CodeCatalyst 中的個別檔案，與套件版本相關聯，例如 npm `.tgz` 檔案或 Maven POM 或 JAR 檔案。

## 套件儲存庫
<a name="packages-concepts-repository"></a>

CodeCatalyst *套件儲存庫*包含一組[套件](#packages-concepts-packages)，其中包含[套件版本](#packages-concepts-package-versions)，每個版本都會對應至一組[資產](#packages-concepts-assets)。套件儲存庫是多槽，這表示單一儲存庫可包含任何支援類型的套件。每個套件儲存庫都會公開端點，以使用 NuGet CLIs(`nuget`、`dotnet`)、`npm`CLI、Maven CLI (`mvn`) 和 Python CLIs(`pip` 和 ) 等工具來擷取和發佈套件`twine`。如需 CodeCatalyst 中套件配額的相關資訊，包括在每個空間中可以建立多少個套件儲存庫，請參閱 [套件的配額](packages-quotas.md)。

您可以將套件儲存庫設定為上游，以將其連結至另一個儲存庫。當儲存庫設定為上游時，您可以使用來自上游的任何套件，以及鏈結中的任何其他上游儲存庫。如需詳細資訊，請參閱[上游儲存庫](#packages-concepts-upstream-repositories)。

閘道儲存庫是一種特殊類型的套件儲存庫，可從官方外部套件授權單位提取和存放套件。如需詳細資訊，請參閱[閘道儲存庫](#packages-concepts-gateway-repositories)。

## 上游儲存庫
<a name="packages-concepts-upstream-repositories"></a>

您可以使用 CodeCatalyst 在兩個套件儲存庫之間建立上游關係。當套件儲存庫包含的套件版本可從下游儲存庫的套件儲存庫端點存取時，套件儲存庫是另一個 的*上游*。使用上游關係時，兩個套件儲存庫的內容會從用戶端的角度有效地合併。

例如，如果套件管理員請求的套件版本不存在於儲存庫中，則 CodeCatalyst 會搜尋套件版本的已設定上游儲存庫。上游儲存庫會依設定的順序進行搜尋，一旦找到套件，CodeCatalyst 就會停止搜尋。

## 閘道儲存庫
<a name="packages-concepts-gateway-repositories"></a>

*閘道儲存庫*是一種特殊類型的套件儲存庫，連接到支援的外部官方套件授權單位。當您將閘道儲存庫新增為[上游儲存庫](#packages-concepts-upstream-repositories)時，您可以從對應的官方套件授權機構取用套件。您的下游儲存庫不會與公有儲存庫通訊，而是所有內容都會由閘道儲存庫中繼。以這種方式取用的套件會存放在閘道儲存庫和接收原始請求的下游儲存庫中。

閘道儲存庫是預先定義的，但必須在要使用的每個專案中建立。下列清單包含可在 CodeCatalyst 中建立的每個閘道儲存庫，以及其連線的套件授權。
+ **npm-public-registry-gateway** 提供來自 npmjs.com：// 的 npm 套件。
+ **maven-central-gateway** 提供來自 Maven Central 儲存庫的 Maven 套件。
+ **google-android-gateway** 提供來自 Google Android 的 Maven 套件。
+ **commonsware-gateway** 提供來自 CommonsWare 的 Maven 套件。
+ **gradle-plugins-gateway** 提供來自 Gradle 外掛程式的 Maven 套件。
+ **nuget-gallery-gateway** 提供來自 NuGet Gallery 的 NuGet 套件。
+ **pypi-gateway** 從 Python 套件索引提供 Python 套件。

# 設定和使用套件儲存庫
<a name="packages-repositories"></a>

在 CodeCatalyst 中，套件會在套件儲存庫中存放和管理。若要將套件發佈至 CodeCatalyst，或從 CodeCatalyst （或任何支援的公有套件儲存庫） 取用套件，您必須建立套件儲存庫，並將套件管理員連接至該儲存庫。

**Topics**
+ [建立套件儲存庫](packages-repositories-create.md)
+ [連接至套件儲存庫](packages-repositories-connect.md)
+ [刪除套件儲存庫](packages-repositories-delete.md)

# 建立套件儲存庫
<a name="packages-repositories-create"></a>

執行下列步驟以在 CodeCatalyst 中建立套件儲存庫。

**建立套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 導覽至您要在其中建立套件儲存庫的專案。

1. 從導覽窗格中，選擇**套件**。

1. 在**套件儲存庫**頁面上，選擇**建立套件儲存庫**。

1. 在**套件儲存庫詳細資訊**區段中，新增下列項目：

   1. **儲存庫名稱**。請考慮使用描述性名稱搭配詳細資訊，例如您的專案或團隊名稱，或儲存庫的使用方式。

   1. （選用） **描述**。當您在專案中的多個團隊中有多個儲存庫時，儲存庫描述特別有用。

1. 在**上游儲存庫**區段中，選擇**選取上游儲存庫**，以新增您想要透過 CodeCatalyst 套件儲存庫存取的任何套件儲存庫。您可以新增**閘道儲存庫**，以連線至外部套件儲存庫或其他 **CodeCatalyst 儲存庫**。

   1. 從套件儲存庫請求套件時，上游儲存庫會依在此清單中顯示的順序進行搜尋。找到套件後，CodeCatalyst 將停止搜尋。若要變更上游儲存庫的順序，您可以在清單中拖放儲存庫。

1. 選擇**建立**以建立套件儲存庫。

# 連接至套件儲存庫
<a name="packages-repositories-connect"></a>

若要從 CodeCatalyst 發佈或取用套件，您必須使用套件儲存庫端點資訊和 CodeCatalyst 登入資料來設定套件管理員。如果您尚未建立儲存庫，您可以依照 中的指示執行此操作[建立套件儲存庫](packages-repositories-create.md)。

如需如何將套件管理員連線至 CodeCatalyst 套件儲存庫的指示，請參閱下列文件。
+ [設定和使用 Gradle Groovy](packages-maven-gradle.md)
+ [設定和使用 mvn](packages-maven-mvn.md)
+ [設定和使用 nuget 或 dotnet CLI](packages-nuget-cli.md)
+ [設定和使用 npm](packages-npm-use.md)
+ [設定 pip 和安裝 Python 套件](packages-python-pip.md)
+ [設定 Twine 和發佈 Python 套件](packages-python-twine.md)

# 刪除套件儲存庫
<a name="packages-repositories-delete"></a>

執行下列步驟以刪除 CodeCatalyst 中的套件儲存庫。

**刪除套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 導覽至包含您要刪除之套件儲存庫的專案。

1. 從導覽窗格中，選擇**套件**。

1. 在**套件儲存庫**頁面上，選擇您要刪除的儲存庫。

1. 選擇 **刪除**。

1. 檢閱有關刪除套件儲存庫效果的資訊。

1. 在輸入欄位中輸入 `delete` ，然後選擇**刪除**。

# 設定和使用上游儲存庫
<a name="packages-upstream-repositories"></a>

您可以將閘道儲存庫和其他 CodeCatalyst 套件儲存庫做為上游連接至套件儲存庫。這可讓套件管理員用戶端使用單一套件儲存庫端點，存取包含在多個套件儲存庫中的套件。以下是使用上游儲存庫的主要優點：
+ 您只需使用單一儲存庫端點來設定套件管理員，即可從多個來源提取。
+ 從上游儲存庫取用的套件會存放在您的下游儲存庫中，這可確保即使上游儲存庫遇到意外中斷或上游儲存庫中的套件遭到刪除，您的套件仍可使用。

您可以在建立套件儲存庫時新增上游儲存庫。您也可以在 CodeCatalyst 主控台中，從現有的套件儲存庫新增或移除上游儲存庫。

當您將閘道儲存庫新增為上游儲存庫時，套件儲存庫會連線至閘道儲存庫對應的公有套件儲存庫。如需支援的公有套件儲存庫清單，請參閱 [支援的外部套件儲存庫及其閘道儲存庫](packages-connect-external.md#packages-upstream-repositories-supported-external)。

您可以將多個儲存庫連結為上游儲存庫。例如，假設您的團隊建立名為 的儲存庫，`project-repo`並且已經使用另一個名為 `team-repo` 的儲存庫，該儲存庫將 **npm-public-registry-gateway** 新增為上游儲存庫，該儲存庫連接到公有 npm 儲存庫 `npmjs.com`。您可以新增 `team-repo`做為 的上游儲存庫`project-repo`。在此情況下，您只需將套件管理員設定為使用 從 `project-repo`、、 `team-repo``npm-public-registry-gateway`和 `project-repo`提取套件`npmjs.com`。

**Topics**
+ [新增上游儲存庫](packages-upstream-repositories-add.md)
+ [編輯上游儲存庫的搜尋順序](packages-upstream-repositories-search-order.md)
+ [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)
+ [移除上游儲存庫](packages-upstream-repositories-remove.md)

# 新增上游儲存庫
<a name="packages-upstream-repositories-add"></a>

將公有套件儲存庫或其他 CodeCatalyst 套件儲存庫做為上游儲存庫新增至下游儲存庫，可讓連線至下游儲存庫的套件管理員使用上游儲存庫中的所有套件。

**新增上游儲存庫**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇要新增上游儲存庫的套件儲存庫。

1. 在套件儲存庫的名稱下，選擇**上游**，然後選擇**選取上游儲存庫**。

1. 在**選取上游類型**中，選擇下列其中一項：
   + **閘道儲存庫**

     您可以從可用的閘道儲存庫清單中選擇。
**注意**  
若要連線到公有外部套件授權單位，例如 Maven Central、npmjs.com 或 Nuget Gallery，CodeCatalyst 會使用閘道儲存庫做為中介儲存庫，以搜尋和存放從外部儲存庫提取的套件。這可節省時間和資料傳輸，因為專案中的所有套件儲存庫將使用來自閘道中介儲存庫的套件。如需詳細資訊，請參閱[連線到公有外部儲存庫](packages-connect-external.md)。
   + **CodeCatalyst 儲存庫**

     您可以從專案中可用的 CodeCatalyst 套件儲存庫清單中選擇。

1. 當您選取所有要新增為上游儲存庫的儲存庫時，請選擇**選取**，然後選擇**儲存**。

   如需變更上游儲存庫搜尋順序的詳細資訊，請參閱 [編輯上游儲存庫的搜尋順序](packages-upstream-repositories-search-order.md)。

新增上游儲存庫後，您可以使用連線至本機儲存庫的套件管理員，從上游儲存庫擷取套件。您不需要更新套件管理員組態。如需從上游儲存庫請求套件版本的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

# 編輯上游儲存庫的搜尋順序
<a name="packages-upstream-repositories-search-order"></a>

CodeCatalyst 會依設定的搜尋順序搜尋上游儲存庫。找到套件時，CodeCatalyst 會停止搜尋。您可以變更上游儲存庫搜尋套件的順序。

**編輯上游儲存庫的搜尋順序**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇您要編輯其上游儲存庫搜尋順序的套件儲存庫。

1. 在套件儲存庫的名稱下，選擇**上游**。

1. 在**上游儲存庫**區段中，您可以檢視上游儲存庫及其搜尋順序。若要變更搜尋順序，請將儲存庫拖放到清單中。

1. 當您完成上游儲存庫的搜尋順序編輯後，請選擇**儲存**。

# 使用上游儲存庫請求套件版本
<a name="packages-upstream-repositories-request"></a>

下列範例顯示套件管理員從具有上游儲存庫的 CodeCatalyst 套件儲存庫請求套件的可能案例。

在此範例中，套件管理員，例如 `npm`，會從具有多個上游儲存庫`downstream`且名為 的套件儲存庫請求套件版本。請求套件時，可能會發生下列情況：
+  如果 `downstream`包含請求的套件版本，則會傳回給用戶端。
+  如果 `downstream` 不包含請求的套件版本，CodeCatalyst 會以其設定的搜尋順序，在 `downstream`的上游儲存庫中搜尋它。如果找到套件版本，則會將其參考複製到 `downstream`，並將套件版本傳回給用戶端。
+  如果 `downstream`或其上游儲存庫都不包含套件版本，則會將 HTTP 404 `Not Found`回應傳回給用戶端。

 一個儲存庫允許的直接上游儲存庫數量上限為 10。請求套件版本時CodeCatalyst 搜尋的儲存庫數目上限為 25。

## 來自上游儲存庫的套件保留
<a name="package-retention-upstream-repos"></a>

如果在上游儲存庫中找到請求的套件版本，則會保留其參考，並且一律可在請求它的儲存庫中使用。這可確保在上游儲存庫發生意外中斷時，您可以存取套件。保留的套件版本不受下列任何一項影響：
+  刪除上游儲存庫。
+  中斷上游儲存庫與下游儲存庫的連線。
+  從上游儲存庫刪除套件版本。
+  在上游儲存庫中編輯套件版本 （例如，將新資產新增至該儲存庫）。

## 透過上游關係擷取套件
<a name="fetching-packages-through-an-upstream-relationship"></a>

CodeCatalyst 可以透過稱為上游儲存庫的多個連結儲存庫來擷取套件。如果 CodeCatalyst 套件儲存庫與另一個與閘道儲存庫有上游連線的 CodeCatalyst 套件儲存庫有上游連線，則會從外部儲存庫複製不在上游儲存庫中的套件請求。例如，請考慮下列組態：名為 的儲存庫與閘道儲存庫`repo-A`有上游連線，`npm-public-registry-gateway`。 `npm-public-registry-gateway`與公有套件儲存庫有上游連線，https：//[https://npmjs.com](https://npmjs.com)。

![\[簡單的上游儲存庫圖表顯示三個鏈結在一起的儲存庫。\]](http://docs.aws.amazon.com/zh_tw/codecatalyst/latest/userguide/images/packages/upstream-with-external.png)


如果 `npm` 設定為使用 `repo-A`儲存庫，則執行 會`npm install`啟動將套件從 [https://npmjs.com](https://npmjs.com) 複製到 `npm-public-registry-gateway`。已安裝的版本也會提取至 `repo-A`。下列範例會安裝 `lodash`。

```
$ npm config get registry
https://packages.region.codecatalyst.aws/npm/space-name/proj-name/repo-name/
$ npm install lodash
+ lodash@4.17.20
added 1 package from 2 contributors in 6.933s
```

執行 之後`npm install`， 只`repo-A`包含最新版本 (`lodash 4.17.20`)，因為這是 `npm`自 擷取的版本`repo-A`。

 由於 `npm-public-registry-gateway`具有與 [https://npmjs.com](https://npmjs.com) 的外部上游連線，因此從 [https://npmjs.com](https://npmjs.com) 匯入的所有套件版本都會存放在 中`npm-public-registry-gateway`。這些套件版本可由任何上游連線導致 的下游儲存庫擷取`npm-public-registry-gateway`。

的內容`npm-public-registry-gateway`可讓您查看從 [https://npmjs.com](https://npmjs.com) 匯入的所有套件和套件版本。

## 中繼儲存庫中的套件保留
<a name="package-retention-intermediate-repositories"></a>

 CodeCatalyst 可讓您鏈結上游儲存庫。例如， `repo-A`可以讓 `repo-B`做為上游儲存庫，`repo-B`也可以讓 `repo-C`做為上游儲存庫。此組態可讓 中的套件版本，`repo-B`以及從 `repo-C`取得的套件版本`repo-A`。

![\[簡單的上游儲存庫圖表顯示三個鏈結在一起的儲存庫。\]](http://docs.aws.amazon.com/zh_tw/codecatalyst/latest/userguide/images/packages/upstream-chaining.png)


 當套件管理員連線至儲存庫`repo-A`並從儲存庫 擷取套件版本時`repo-C`，套件版本不會保留在儲存庫 中`repo-B`。套件版本只會保留在最新的下游儲存庫中，在此範例中為 `repo-A`。它不會保留在任何中繼儲存庫中。對於較長的鏈結也是如此；例如，如果有四個儲存庫：`repo-A`、`repo-C`、 `repo-B`和 `repo-D`，以及連接到從 `repo-A` 擷取套件版本的套件管理員`repo-D`，套件版本將保留在 中`repo-A`，但不保留在 `repo-B`或 中`repo-C`。

從公有套件儲存庫提取套件版本時，套件保留行為類似，但套件版本一律保留在與公有儲存庫有直接上游連線的閘道儲存庫中。例如， `repo-A` 將 `repo-B`作為上游儲存庫。 `repo-B` 將 `npm-public-registry-gateway`作為上游儲存庫，其與公有儲存庫 **npmjs.com** 具有上游連線；請參閱下圖。

![\[上游儲存庫圖表顯示三個與 npmjs.com 外部上游連線鏈結在一起的儲存庫。\]](http://docs.aws.amazon.com/zh_tw/codecatalyst/latest/userguide/images/packages/upstream-chaining-external.png)


 如果連接至 的套件管理員`repo-A`請求特定套件版本，例如 *lodash 4.17.20*，且套件版本不存在於三個儲存庫中的任何一個，則會從 **npmjs.com**：// 擷取套件版本。擷取 *lodash 4.17.20* 時，它會保留在 中`repo-A`，因為這是最遠的下游儲存庫，`npm-public-registry-gateway`而且它具有與公有外部儲存庫 **npmjs.com** 的上游連線。*lodash 4.17.20* 不會保留在 中，`repo-B`因為這是中繼儲存庫。

# 移除上游儲存庫
<a name="packages-upstream-repositories-remove"></a>

如果您不想再存取上游儲存庫中的套件，您可以從套件儲存庫中移除上游儲存庫。

**警告**  
當您移除上游儲存庫時，可能會中斷上游關係鏈，進而中斷您的專案或建置。

**移除上游儲存庫**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇您要從中移除上游儲存庫的套件儲存庫。

1. 在套件儲存庫的名稱下，選擇**上游**。

1. 在**編輯上游儲存庫**區段中，尋找您要移除的上游儲存庫，然後選擇 ![\[Remove\]](http://docs.aws.amazon.com/zh_tw/codecatalyst/latest/userguide/images/packages/remove.png)。

1. 完成移除上游儲存庫後，請選擇**儲存**。

# 連線到公有外部儲存庫
<a name="packages-connect-external"></a>

您可以將對應的閘道儲存庫新增為上游儲存庫，將 CodeCatalyst 套件儲存庫連線至支援的公有外部儲存庫。閘道儲存庫做為中介儲存庫，可搜尋和存放從外部儲存庫提取的套件。這可節省時間和資料傳輸，因為專案中的所有套件儲存庫都可以使用來自閘道儲存庫的儲存套件。

**使用閘道儲存庫連線至公有儲存庫**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件**中，選擇**閘道儲存庫**頁面。您可以檢視支援的閘道儲存庫清單及其描述。

1. 若要使用閘道儲存庫，您必須先建立它。如果閘道儲存庫已建立，則會顯示建立的日期和時間。如果尚未建立，請選擇**建立**以建立。

1. 若要使用來自閘道儲存庫的套件，您必須從 CodeCatalyst 儲存庫設定與其的上游連線。選擇**套件儲存庫**，然後選擇您要連線的套件儲存庫。

1. 若要連線至公有儲存庫，請選擇**上游**，然後選擇**選取上游儲存庫**。

1. 選擇**閘道儲存庫** 選取對應至您要做為上游儲存庫 連線之公有儲存庫的閘道儲存庫。

1. 選取要新增為上游儲存庫的所有閘道儲存庫後，請選擇**選取**。

1. 完成上游儲存庫的排序後，請選擇**儲存**。

如需上游儲存庫的詳細資訊，請參閱 [設定和使用上游儲存庫](packages-upstream-repositories.md)。

當您將閘道儲存庫新增為上游儲存庫時，您可以使用連線至本機儲存庫的套件管理員，從與其對應的公有外部套件儲存庫擷取套件。您不需要更新套件管理員組態。以這種方式使用的套件會同時存放在閘道儲存庫和本機套件儲存庫中。如需從上游儲存庫請求套件版本的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

## 支援的外部套件儲存庫及其閘道儲存庫
<a name="packages-upstream-repositories-supported-external"></a>

CodeCatalyst 支援使用閘道儲存庫將上游連線新增至下列官方套件授權單位。


| 儲存庫套件類型 | Description | 閘道儲存庫名稱 | 
| --- | --- | --- | 
| npm | npm 公有登錄檔 | npm-public-registry-gateway | 
| Python | Python 套件索引 | pypi-gateway | 
| Maven | Maven Central | maven-central-gateway | 
| Maven | Google Android 儲存庫 | google-android-gateway | 
| Maven | CommonsWare | commonsware-gateway | 
| Maven | Gradle 外掛程式儲存庫 | gradle-plugins-gateway | 
| NuGet | NuGet 圖庫 | nuget-gallery-gateway | 

# 發佈和修改套件
<a name="working-with-packages"></a>

CodeCatalyst 中的*套件*是軟體和中繼資料的套件，這些中繼資料是解決相依性和安裝軟體所需的。如需 CodeCatalyst 中支援的套件格式清單，請參閱 [在 CodeCatalyst 中發佈和共用軟體套件](packages.md)。本節提供有關發佈、檢視、刪除套件和更新套件版本狀態的資訊。

**Topics**
+ [將套件發佈至 CodeCatalyst 套件儲存庫](package-publishing.md)
+ [檢視套件版本詳細資訊](working-with-packages-view.md)
+ [刪除套件版本](working-with-packages-delete.md)
+ [更新套件版本的狀態](working-with-packages-update-version-status.md)
+ [編輯套件原始伺服器控制項](package-origin-controls.md)

# 將套件發佈至 CodeCatalyst 套件儲存庫
<a name="package-publishing"></a>

 您可以使用套件管理員工具，將任何支援套件類型的版本發佈至 CodeCatalyst 套件儲存庫。發佈套件版本的步驟如下：

**將套件版本發佈至 CodeCatalyst 套件儲存庫**

1. 如果您尚未建立，[請建立套件儲存庫](packages-repositories-create.md)。

1. 將套件管理員連接到套件儲存庫。如需如何將 npm 套件管理員連線至 CodeCatalyst 套件儲存庫的指示，請參閱 [設定和使用 npm](packages-npm-use.md)。

1. 使用連線的套件管理員發佈套件版本。

**Contents**
+ [發佈和上游儲存庫](#package-publishing-upstreams)
+ [私有套件和公有儲存庫](#package-publishing-upstreams-direct)
+ [覆寫套件資產](#package-publishing-overwrite-assets)

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

在 CodeCatalyst 中，您無法發佈可連線上游儲存庫或公有儲存庫中存在的套件版本。例如，假設您想要將 npm 套件 發佈`lodash@1.0`至套件儲存庫 `myrepo`和 透過設定為上游儲存庫的閘道儲存庫`myrepo`連線至 npmjs.com。如果上游儲存庫或 npmjs.com 中存在 `lodash@1.0` ，CodeCatalyst `myrepo`會發出 409 衝突錯誤，拒絕在 中發佈任何嘗試。這有助於防止您不小心發佈與上游儲存庫中套件名稱和版本相同的套件，這可能會導致意外行為。

您仍然可以發佈上游儲存庫中存在的不同版本套件名稱。例如，如果 `lodash@1.0` 存在於上游儲存庫中，但 `lodash@1.1` 不存在，您可以發佈`lodash@1.1`到下游儲存庫。

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

 CodeCatalyst 不會將儲存在 CodeCatalyst 儲存庫中的套件發佈至公有儲存庫，例如 npmjs.com 或 Maven Central。CodeCatalyst 會將套件從公有儲存庫匯入 CodeCatalyst 儲存庫，但不會以相反方向移動套件。您發佈至 CodeCatalyst 儲存庫的套件會保持私有，且僅適用於儲存庫所屬的 CodeCatalyst 專案。

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

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

對於支援多個資產 (Python 和 Maven) 的套件格式，您可以隨時將名稱不同的新資產新增至現有的套件版本，前提是您具有必要的許可。由於 npm 和 NuGet 每個套件版本僅支援單一資產，若要修改已發佈的套件版本，您必須先將其刪除。

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

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

您可以使用 CodeCatalyst 主控台來檢視特定套件版本的詳細資訊。

**檢視套件版本詳細資訊**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇包含您要檢視詳細資訊之套件版本的儲存庫。

1. 在套件資料表中搜尋**套件**版本。您可以使用搜尋列，依套件名稱和格式篩選套件。從清單中選擇套件。

1. 在**套件詳細資訊**頁面中，選擇**版本**，然後選擇您要檢視的版本。

# 刪除套件版本
<a name="working-with-packages-delete"></a>

您可以從 CodeCatalyst 主控台的套件版本**詳細資訊頁面刪除套件版本**。

**刪除套件版本**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇包含您要刪除之套件版本的儲存庫。

1. 搜尋並從資料表中選擇套件。

1. 在**套件詳細資訊**頁面上，選擇**版本**，然後選擇您要刪除的版本。

1. 在**套件版本詳細資訊**頁面上，選擇**版本動作**，然後選擇**刪除**。

1. 在文字欄位中輸入 *Delete*，然後選擇 **Delete**。

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

CodeCatalyst 中的每個套件版本都有一個狀態，描述套件版本的目前狀態和可用性。您可以在 CodeCatalyst 主控台中變更套件版本狀態。如需套件版本可能的狀態值及其意義的詳細資訊，請參閱 [套件版本狀態](#package-version-status)。

**更新套件版本的狀態**

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 在**套件儲存庫**頁面上，選擇包含您要更新狀態之套件版本的儲存庫。

1. 搜尋並從資料表中選擇套件。

1. 在**套件詳細資訊**頁面上，選擇**版本**，然後選擇您要檢視的版本。

1. 在**套件版本詳細資訊**頁面上，選擇**動作**，然後選擇**取消清單**、**封存**或**處置**。如需每個套件版本狀態的資訊，請參閱 [套件版本狀態](#package-version-status)。

1. 在文字欄位中輸入確認文字，然後選擇**取消清單**、**存檔**或**處置**，視您要更新的狀態而定。

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

以下是套件版本狀態的可能值。您可以在 主控台中變更套件版本狀態。如需詳細資訊，請參閱[更新套件版本的狀態](#working-with-packages-update-version-status)。
+  **已發佈**：套件版本已成功發佈，且可由套件管理員請求。套件版本將包含在傳回給套件管理員的套件版本清單中；例如，在 的輸出中`npm view <package-name> versions`。套件版本的所有資產皆可從 儲存庫取得。
+  **未完成**：上次嘗試發佈並未完成。目前只有 Maven 套件版本可以具有**未完成**的狀態。當用戶端為套件版本上傳一或多個資產，但不為包含該版本的套件發佈`maven-metadata.xml`檔案時，就會發生這種情況。
+  **未列出**：套件版本資產可從儲存庫下載，但套件版本不包含在傳回給套件管理員的版本清單中。例如，對於 npm 套件， 的輸出`npm view <package-name> versions`不包含套件版本。這表示 npm 相依性解析邏輯不會選取套件版本，因為版本不會出現在可用版本清單中。不過，如果 `npm package-lock.json`檔案中已參考**未列出的**套件版本，仍然可以下載並安裝；例如，執行 時`npm ci`。
+  **已封存**：無法下載套件版本資產。套件版本不會包含在傳回給套件管理員的版本清單中。由於資產無法使用，用戶端對套件版本的使用會遭到封鎖。如果您的應用程式建置取決於更新為**已封存**的版本，除非套件版本已在本機快取，否則建置將會失敗。您無法使用套件管理員或建置工具來重新發佈**封存**套件版本，因為它仍然存在於儲存庫中。不過，您可以將套件版本狀態變更回主控台中的**未列出**或**已發佈**。
+  **已處置**：套件版本不會顯示在清單中，且資產無法從儲存庫下載。**Disposed** 和 **Archived** 之間的主要區別在於，狀態為 **Disposed** 時，CodeCatalyst 會永久刪除套件版本的資產。因此，您無法將套件版本從**處置**移至**已封存**、**未列出**或**已發佈**。套件版本無法使用，因為已刪除資產。當套件版本標示為**已處置**時，您不需要支付套件資產的儲存費用。

 除了上述清單中的狀態之外，也可以刪除套件版本。刪除後，套件版本不會在儲存庫中，您可以使用套件管理員或建置工具自由重新發佈該套件版本。

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

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

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

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

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

您應該考慮設定套件原始伺服器控制，讓不同套件的新版本來自兩個內部來源，例如直接發佈和外部來源，例如公有儲存庫。根據預設，套件原始伺服器控制是根據將套件的第一個版本新增至儲存庫的方式進行設定。

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

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

**發布**

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

**上游**

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

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

套件的預設套件原始伺服器控制項將根據該套件的第一個版本如何新增至套件儲存庫。
+ 如果第一個套件版本是由套件管理員正確發佈，則設定將是**發佈：允許**和**上游：鎖定**。
+ 如果從公有來源擷取第一個套件版本，則設定將是**發佈：封鎖**和**上游：允許**。

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

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

在下列案例中，*內部套件*會直接從套件管理員發佈到您的儲存庫，例如您維護的套件。*外部套件*是存在於公有儲存庫中的套件，可透過閘道儲存庫上游擷取到您的儲存庫。

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

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

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

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


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

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

在下圖中，*repoA* 是具有與儲存庫上游連線的 CodeCatalyst 套件`npm-public-registry-gateway`儲存庫。您的套件儲存庫包含從公有儲存庫擷取的 3.0 版。您想要將 1.2 版發佈至套件儲存庫。一般而言，您可以將 1.2 版發佈至 *repoA*，但由於發佈設定為 **Block**，因此無法發佈 1.2 版。

![\[顯示套件發佈已封鎖的簡單圖形。\]](http://docs.aws.amazon.com/zh_tw/codecatalyst/latest/userguide/images/packages/package-origin-controls-two.png)


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

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

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

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

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

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 選擇包含您要編輯之套件的套件儲存庫。

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

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

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

1. 選擇**儲存**。

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

在 CodeCatalyst 中，您無法發佈可連線上游儲存庫或公有儲存庫中存在的套件版本。例如，假設您想要將 npm 套件發佈`lodash@1.0`到 儲存庫， `myrepo`和 `myrepo`具有與 npmjs.com 外部連線的上游儲存庫。請考慮下列案例。

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

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

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

## 相依性替代攻擊
<a name="dependency-substitution-attacks"></a>

套件管理員可簡化封裝和共用可重複使用程式碼的程序。這些套件可能是組織開發用於其應用程式的私有套件，也可能是公有套件，通常是在組織外部開發並由公有套件儲存庫分發的開放原始碼套件。請求套件時，開發人員依賴其套件管理員來擷取其相依性的新版本。相依性替代攻擊也稱為相依性混淆攻擊，利用套件管理員通常無法區分套件的合法版本與惡意版本這一事實。

相依性替代攻擊屬於稱為軟體供應鏈攻擊的攻擊子集。軟體供應鏈攻擊是一種利用軟體供應鏈中任何位置漏洞的攻擊。

相依性替代攻擊可以針對任何同時使用內部開發的套件和從公有儲存庫擷取的套件。攻擊者會識別內部套件名稱，然後在公有套件儲存庫中以策略方式放置同名的惡意程式碼。一般而言，惡意程式碼會發佈在版本編號較高的套件中。套件管理員會從這些公有饋送擷取惡意程式碼，因為他們認為惡意程式套件是套件的最新版本。這會導致所需套件和惡意套件之間的「混淆」或「替代」，這會導致程式碼洩露。

為了防止相依性替代攻擊，Amazon CodeCatalyst 提供套件原始伺服器控制。套件原始伺服器控制是控制套件如何新增至儲存庫的設定。當新套件的第一個套件版本新增至 CodeCatalyst 儲存庫時，會自動設定控制項。控制項可確保套件版本無法直接發佈至您的儲存庫並從公有來源擷取，以保護您免受相依性替代攻擊。如需套件原始伺服器控制以及如何變更它們的詳細資訊，請參閱 [編輯套件原始伺服器控制項](#package-origin-controls)。

# 使用 NPM
<a name="packages-npm"></a>

這些主題說明如何搭配 CodeCatalyst 使用 `npm`Node.js 套件管理員 。

**注意**  
CodeCatalyst 支援 `node v4.9.1` 和更新版本以及 `npm v5.0.0`和更新版本。

**Topics**
+ [設定和使用 npm](packages-npm-use.md)
+ [npm 標籤處理](packages-npm-tags.md)

# 設定和使用 npm
<a name="packages-npm-use"></a>

若要`npm`搭配 CodeCatalyst 使用 ，您必須`npm`連線至套件儲存庫，並提供個人存取字符 (PAT) 以進行身分驗證。您可以在 CodeCatalyst 主控台中檢視`npm`連線至套件儲存庫的指示。

**Contents**
+ [使用 CodeCatalyst 設定 npm](#npm-configure)
+ [從 CodeCatalyst 套件儲存庫安裝 npm 套件](#npm-install)
+ [透過 CodeCatalyst 從 npmjs 安裝 npm 套件](#npm-install-npmjs)
+ [將 npm 套件發佈到您的 CodeCatalyst 套件儲存庫](#npm-publish)
+ [npm 命令支援](#npm-commands)
  + [與套件儲存庫互動的支援命令](#supported-commands-that-interact-with-a-repository)
  + [支援的用戶端命令](#supported-client-side-commands)
  + [不支援的命令](#unsupported-commands)

## 使用 CodeCatalyst 設定 npm
<a name="npm-configure"></a>

下列指示說明如何驗證並`npm`連線至 CodeCatalyst 套件儲存庫。如需 npm 的詳細資訊，請參閱[官方 npm 文件](https://docs.npmjs.com/)。

**`npm` 連線至 CodeCatalyst 套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 導覽至您的專案。

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 從清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**組態詳細資訊**的**套件管理員用戶端**中，選擇 **npm 用戶端**。

1. 選擇您的作業系統以檢視對應的組態步驟。

1. 需要個人存取字符 (PAT) 才能向 CodeCatalyst 驗證 npm。如果您已經有權杖，則可以使用它。如果沒有，您可以使用下列步驟建立一個。

   1. **（選用）：**更新 **PAT 名稱**和**過期日期**。

   1. 選擇**建立權杖**。

   1. 將 PAT 複製並存放在安全的位置。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。登入資料應該短暫存在，以盡量減少攻擊者在盜用登入資料之後可以使用登入資料的時間長度。

1. 從專案的根目錄執行下列命令，以使用套件儲存庫設定 npm。這些命令會執行下列動作：
   + 如果您的專案沒有專案層級`.npmrc`檔案，請建立專案層級檔案。
   + 將套件儲存庫端點資訊新增至您的專案層級`.npmrc`檔案。
   + 將您的登入資料 (PAT) 新增至您的使用者層級`.npmrc`檔案。

   取代下列值。
**注意**  
如果您要從主控台指示複製 ，則會為您更新下列命令中的值，而且不需要變更。
   + 將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱。
   + 將 *PAT* 取代為您的 CodeCatalyst PAT。
   + 以您的 CodeCatalyst 空間名稱取代 *space\$1name*。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   npm set registry=https://packages.region.codecatalyst.aws/npm/space-name/proj-name/repo-name/ --location project
   npm set //packages.region.codecatalyst.aws/npm/space-name/proj-name/repo-name/:_authToken=username:PAT
   ```

   **對於 npm 6 或更低：**若要讓 npm 一律將驗證字符傳遞至 CodeCatalyst，即使對於`GET`請求，也請使用 設定永遠驗證組態變數`npm config set`，如下所示。

   ```
   npm set //packages.region.codecatalyst.aws/npm/space-name/proj-name/repo-name/:always-auth=true --location project
   ```

## 從 CodeCatalyst 套件儲存庫安裝 npm 套件
<a name="npm-install"></a>

依照中的步驟將 npm 連接到儲存庫後[使用 CodeCatalyst 設定 npm](#npm-configure)，您可以在儲存庫上執行`npm`命令。

您可以使用 `npm install`命令，在 CodeCatalyst 套件儲存庫或其其中一個上游儲存庫中安裝 npm 套件。

```
npm install lodash
```

## 透過 CodeCatalyst 從 npmjs 安裝 npm 套件
<a name="npm-install-npmjs"></a>

您可以透過 CodeCatalyst 儲存庫從 [npmjs.com](https://www.npmjs.com/) 安裝 npm 套件，方法是將儲存庫設定為與連接至 npmjs.com、**npm-public-registry-gateway** 的閘道儲存庫有上游連線。從 npmjs 安裝的套件會擷取並存放在閘道儲存庫，以及最遠的下游套件儲存庫中。

**從 npmjs 安裝套件**

1. 如果您尚未這麼做，請依照中的步驟`npm`，使用 CodeCatalyst 套件儲存庫進行設定[使用 CodeCatalyst 設定 npm](#npm-configure)。

1. 檢查您的儲存庫是否已新增閘道儲存庫 **npm-public-registry-gateway** 做為上游連線。您可以依照 中的指示[新增上游儲存庫](packages-upstream-repositories-add.md)並選擇 **npm-public-registry-gateway** 儲存庫，來檢查要新增哪些上游來源，或新增 **npm-public-registry-gateway** 做為上游來源。

1. 使用 `npm install`命令安裝套件。

   ```
   npm install package_name
   ```

如需從上游儲存庫請求套件的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

## 將 npm 套件發佈到您的 CodeCatalyst 套件儲存庫
<a name="npm-publish"></a>

完成 後[使用 CodeCatalyst 設定 npm](#npm-configure)，您可以執行 `npm` 命令。

您可以使用 `npm publish`命令將 npm 套件發佈至 CodeCatalyst 套件儲存庫。

```
npm publish
```

如需如何建立 npm 套件的資訊，請參閱在 *npm 文件*上[建立 Node.js 模組](https://docs.npmjs.com/getting-started/creating-node-modules)。

## npm 命令支援
<a name="npm-commands"></a>

下列各節摘要說明 CodeCatalyst 套件儲存庫支援的`npm`命令，以及列出不支援的特定命令。

**Topics**
+ [與套件儲存庫互動的支援命令](#supported-commands-that-interact-with-a-repository)
+ [支援的用戶端命令](#supported-client-side-commands)
+ [不支援的命令](#unsupported-commands)

### 與套件儲存庫互動的支援命令
<a name="supported-commands-that-interact-with-a-repository"></a>

本節列出 `npm` 命令，其中`npm`用戶端會對其設定的登錄檔提出一或多個請求 （例如 `npm config set registry`)。已驗證這些命令在針對 CodeCatalyst 套件儲存庫調用時可正常運作。


****  

| 命令 | Description | 
| --- | --- | 
|   [錯誤](https://docs.npmjs.com/cli/bugs)   |  猜測套件錯誤追蹤器 URL 的位置，然後嘗試開啟它。  | 
|   [ci](https://docs.npmjs.com/cli/ci)   |  安裝具有乾淨板塊的專案。  | 
|   [棄用](https://docs.npmjs.com/cli/deprecate)   |  棄用套件的版本。  | 
|   [dist-tag](https://docs.npmjs.com/cli/dist-tag)   |  修改套件分佈標籤。  | 
|   [文件](https://docs.npmjs.com/cli/docs)   |  猜測套件文件 URL 的位置，然後使用 `--browser` 組態參數嘗試開啟它。  | 
|   [醫生](https://docs.npmjs.com/cli/doctor)   |  執行一組檢查，以驗證您的 npm 安裝是否可以管理您的 JavaScript 套件。  | 
|   [安裝](https://docs.npmjs.com/cli/install)   |  安裝套件。  | 
|   [install-ci-test](https://docs.npmjs.com/cli/install-ci-test)   |  安裝具有乾淨板塊的專案並執行測試。別名：`npm cit`。此命令會執行 `npm ci`，後面接著 `npm test`。  | 
|   [install-test](https://docs.npmjs.com/cli/install-test)   |  安裝套件並執行測試。執行 `npm install`，後面接著 `npm test`。  | 
|   [過時](https://docs.npmjs.com/cli/outdated)   |  檢查設定的登錄檔，以判斷任何已安裝的套件是否已過時。  | 
|   [ping](https://docs.npmjs.com/cli/ping)   |  Ping 已設定或指定的 npm 登錄檔，並驗證身分驗證。  | 
|   [發佈](https://docs.npmjs.com/cli/publish)   |  將套件版本發佈至登錄檔。  | 
|   [update](https://docs.npmjs.com/cli/update)   |  猜測套件儲存庫 URL 的位置，然後使用 `--browser` 組態參數嘗試開啟它。  | 
|   [檢視](https://docs.npmjs.com/cli/view)   |  顯示套件中繼資料。也可以用來列印中繼資料屬性。  | 

### 支援的用戶端命令
<a name="supported-client-side-commands"></a>

這些命令不需要與套件儲存庫進行任何直接互動，因此 CodeCatalyst 不需要任何支援。


****  

| 命令 | Description | 
| --- | --- | 
|   [bin （舊版）](https://docs.npmjs.com/cli/v8/commands/npm-bin)   |  顯示 npm `bin`目錄。  | 
|   [組建](https://docs.npmjs.com/cli/v6/commands/npm-build)   |  建置套件。  | 
|   [快取](https://docs.npmjs.com/cli/cache)   |  操作套件快取。  | 
|   [完成](https://docs.npmjs.com/cli/completion)   |  在所有 npm 命令中啟用索引標籤完成。  | 
|   [組態](https://docs.npmjs.com/cli/config)   |  更新使用者和全域`npmrc`檔案的內容。  | 
|   [資料刪除](https://docs.npmjs.com/cli/dedupe)   |  搜尋本機套件樹狀目錄，並嘗試透過將相依性進一步移動至樹狀目錄來簡化結構，讓多個相依套件更有效地共用這些樹狀目錄。  | 
|   [編輯](https://docs.npmjs.com/cli/edit)   |  編輯已安裝的套件。選取目前工作目錄中的相依性，並在預設編輯器中開啟套件目錄。  | 
|   [探索](https://docs.npmjs.com/cli/explore)   |  瀏覽已安裝的套件。在指定已安裝套件的 目錄中產生子殼。如果指定命令，則會在 subshell 中執行，然後立即關閉。  | 
|   [help](https://docs.npmjs.com/cli/help)   |  取得 npm 的說明。  | 
|   [help-search](https://docs.npmjs.com/cli/help-search)   |  搜尋 npm 說明文件。  | 
|   [init](https://docs.npmjs.com/cli/init)   |  建立 `package.json` 檔案。  | 
|   [連結](https://docs.npmjs.com/cli/link)   |  Symlink 套件目錄。  | 
|   [ls](https://docs.npmjs.com/cli/ls)   |  列出已安裝的套件。  | 
|   [套件](https://docs.npmjs.com/cli/pack)   |  從套件建立 tarball。  | 
|   [prefix](https://docs.npmjs.com/cli/prefix)   |  顯示字首。除非`-g`另有指定，否則這是包含`package.json`檔案的最接近的父目錄。  | 
|   [黑](https://docs.npmjs.com/cli/prune)棗   |  移除未列在父套件相依性清單上的套件。  | 
|   [重建](https://docs.npmjs.com/cli/rebuild)   |  在相符的資料夾上執行 `npm build`命令。  | 
|   [重新啟動](https://docs.npmjs.com/cli/restart)   |  執行套件的停止、重新啟動和啟動指令碼，以及相關聯的前綴和後綴。  | 
|   [根](https://docs.npmjs.com/cli/root)   |  列印要標準輸出的有效`node_modules`目錄。  | 
|   [run-script](https://docs.npmjs.com/cli/run-script)   |  執行任意套件指令碼。  | 
|   [shrinkwrap](https://docs.npmjs.com/cli/shrinkwrap)   |  鎖定要發佈的相依性版本。  | 
|   [解除安裝](https://docs.npmjs.com/cli/uninstall)   |  解除安裝套件。  | 

### 不支援的命令
<a name="unsupported-commands"></a>

CodeCatalyst 套件儲存庫不支援這些`npm`命令。


****  

| 命令 | Description | 備註 | 
| --- | --- | --- | 
|   [存取](https://docs.npmjs.com/cli/access)   |  設定已發佈套件的存取層級。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的許可模型。  | 
|   [adduser](https://docs.npmjs.com/cli/adduser)   |  新增登錄使用者帳戶  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的使用者模型。  | 
|   [稽核](https://docs.npmjs.com/cli/audit)   |  執行安全稽核。  |  CodeCatalyst 目前不會提供安全漏洞資料。  | 
|   [勾點](https://docs.npmjs.com/cli/v9/commands/npm-hook)   |  管理 npm 勾點，包括新增、移除、列出和更新。  |  CodeCatalyst 目前不支援任何變更通知機制。  | 
|   [登入](https://docs.npmjs.com/cli-commands/adduser.html)   |  驗證使用者。這是 `npm adduser` 的別名。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的身分驗證模型。如需相關資訊，請參閱[使用 CodeCatalyst 設定 npm](#npm-configure)。  | 
|   [登出](https://docs.npmjs.com/cli/logout)   |  登出登錄檔。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的身分驗證模型。您無法從 CodeCatalyst 儲存庫登出，但身分驗證字符會在其可設定的過期時間後過期。預設字符持續時間為 12 小時。  | 
|   [擁有者](https://docs.npmjs.com/cli/owner)   |  管理套件擁有者。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的許可模型。  | 
|   [profile](https://docs.npmjs.com/cli/profile)   |  變更登錄檔設定檔上的設定。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的使用者模型。  | 
|   [search](https://docs.npmjs.com/cli/search)   |  搜尋登錄檔中符合搜尋詞彙的套件。  |  CodeCatalyst 不支援 `search`命令。  | 
|   [星星](https://docs.npmjs.com/cli/star)   |  標記您最愛的套件。  |  CodeCatalyst 目前不支援任何我的最愛機制。  | 
|   [星星](https://docs.npmjs.com/cli/stars)   |  檢視標記為我的最愛之套件。  |  CodeCatalyst 目前不支援任何我的最愛機制。  | 
|   [團隊](https://docs.npmjs.com/cli/team)   |  管理團隊和團隊成員資格。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的使用者和群組成員資格模型。  | 
|   [t](https://docs.npmjs.com/cli/token)oken   |  管理您的身分驗證字符。  |  CodeCatalyst 使用不同的模型來取得身分驗證字符。如需相關資訊，請參閱[使用 CodeCatalyst 設定 npm](#npm-configure)。  | 
|   [取消發佈](https://docs.npmjs.com/cli/unpublish)   |  從登錄檔中移除套件。  |  CodeCatalyst 不支援使用 npm 用戶端從儲存庫移除套件版本。您可以在 主控台中刪除套件。  | 
|   [whoami](https://docs.npmjs.com/cli/whoami)   |  顯示 npm 使用者名稱。  |  CodeCatalyst 使用與公有 npmjs 儲存庫不同的使用者模型。  | 

# npm 標籤處理
<a name="packages-npm-tags"></a>

npm 登錄檔支援*標籤*，這些標籤是套件版本的字串別名。您可以使用標籤來提供別名，而不是使用版本號碼。例如，您有一個具有多個開發串流的專案，並為每個串流使用不同的標籤 （例如，、`stable``beta`、`dev`、`canary`)。如需詳細資訊，請參閱 *npm 文件*上的 [dist-tag](https://docs.npmjs.com/cli/dist-tag)。

根據預設，npm 會使用 `latest`標籤來識別套件的目前版本。 `npm install pkg`（不含 `@version`或 `@tag` 指標） 會安裝最新的標籤。一般而言，專案只會使用最新的標籤來提供穩定的發行版本。其他標籤用於不穩定或發行前版本。

## 使用 npm 用戶端編輯標籤
<a name="editing-tags-with-the-npm-client"></a>

 三個`npm dist-tag`命令 (`add`、 `rm`和 `ls`) 在 CodeCatalyst 套件儲存庫中的運作方式與在[預設 npm 登錄](https://registry.npmjs.com/)檔中的運作方式相同。

## npm 標籤和上游儲存庫
<a name="packages-tags-and-upstreams"></a>

當 `npm`請求套件的標籤，且該套件的版本也存在於上游儲存庫時，CodeCatalyst 會在將標籤傳回用戶端之前合併標籤。例如，名為 的儲存庫`R`具有名為 的上游儲存庫`U`。下表顯示兩個儲存庫中存在`web-helper`的名為 之套件的標籤。


****  

| 儲存庫 | 套件名稱 | 套件標籤 | 
| --- | --- | --- | 
|  R  |  `web-helper`  |   *最新* (1.0.0 版的別名）  | 
|  U  |  `web-helper`  |   *alpha* (1.0.1 版的別名）  | 

在此情況下，當 npm 用戶端從儲存庫 擷取`web-helper`套件的標籤時`R`，它會同時接收*最新*和 *Alpha* 標籤。標籤指向的版本不會變更。

當上游和本機儲存庫中的相同套件上都存在相同的標籤時，CodeCatalyst 會使用*上次更新的*標籤。例如，假設 *webhelper* 上的標籤已修改為如下所示。


****  

| 儲存庫 | 套件名稱 | 套件標籤 | 上次更新 | 
| --- | --- | --- | --- | 
|  R  |  `web-helper`  |   *最新* (1.0.0 版的別名）  |  2023 年 1 月 1 日  | 
|  U  |  `web-helper`  |   *最新* (1.0.1 版的別名）  |  2023 年 6 月 1 日  | 

在此情況下，當 npm 用戶端從儲存庫 擷取套件 *Web-helper* 的標籤時`R`，*最新的*標籤會將 *1.0.1* 版設為別名，因為它上次更新。這可讓您透過執行 ，輕鬆地在尚未存在於本機儲存庫的上游儲存庫中使用新的套件版本`npm update`。

# 使用 Maven
<a name="packages-maven"></a>

Maven 儲存庫格式由許多不同的語言使用，包括 Java、Kotlin、Scala 和 Clojure。它受到許多不同的建置工具支援，包括 Maven、Gradle、Scala SBT、Apache Ivy 和 Leiningen。

我們已針對下列版本測試並確認與 CodeCatalyst 的相容性：
+ 最新 **Maven** 版本：3.6.3。
+ 最新 **Gradle** 版本：6.4.1。5.5.1 版也已經過測試。

**Topics**
+ [設定和使用 Gradle Groovy](packages-maven-gradle.md)
+ [設定和使用 mvn](packages-maven-mvn.md)
+ [使用 curl 發佈套件](packages-maven-curl.md)
+ [使用 Maven 檢查總和和和快照](packages-maven-checksums-snapshots.md)

# 設定和使用 Gradle Groovy
<a name="packages-maven-gradle"></a>

若要搭配 CodeCatalyst 使用 Gradle Groovy，您必須將 Gradle Groovy 連接至套件儲存庫，並提供個人存取字符 (PAT) 進行身分驗證。您可以在 CodeCatalyst 主控台中檢視將 Gradle Groovy 連接到套件儲存庫的指示。

**Contents**
+ [從 CodeCatalyst 擷取相依性](#gradle-fetch-dependencies)
+ [從 CodeCatalyst 擷取外掛程式](#gradle-fetch-plugins)
+ [透過 CodeCatalyst 從外部套件儲存庫擷取套件](#gradle-install-public)
+ [將套件發佈至 CodeCatalyst](#gradle-publish-packages)
+ [在 IntelliJ IDEA 中執行 Gradle 建置](#gradle-intellij)
  + [方法 1：將 PAT 放入 `gradle.properties`](#gradle-intellij-gradle-properties)
  + [方法 2：將 PAT 放在單獨的檔案中](#gradle-intellij-file)

## 從 CodeCatalyst 擷取相依性
<a name="gradle-fetch-dependencies"></a>

下列指示說明如何設定 Gradle Groovy 來擷取 CodeCatalyst 套件儲存庫的相依性。

**使用 Gradle Groovy 從 CodeCatalyst 套件儲存庫擷取相依性**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 導覽至您的專案。

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **Gradle Groovy**。

1. 您需要個人存取字符 (PAT) 才能向 CodeCatalyst 驗證 Gradle Groovy。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 使用存取登入資料更新您的 Gradle 屬性檔案。將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱，並將 *PAT* 取代為您的 CodeCatalyst 個人存取字符。您可以針對 *spaceUsername* 和 *spacePassword* 使用任何值，只要您在下列步驟中使用相同的值。

   ```
   spaceUsername=username
   spacePassword=PAT
   ```

1. 若要從 Gradle 建置中的 CodeCatalyst 擷取相依性，請複製`maven`程式碼片段並將其新增至專案`build.gradle`檔案中的 `repositories`區段。取代下列值。只要您在下列步驟中使用相同的值，就可以將任何值用於 *spaceName*。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   maven {
     name = 'spaceName'
     url = uri('https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/')
     credentials(PasswordCredentials)
   }
   ```

1. （選用） 若要使用 CodeCatalyst 套件儲存庫做為專案相依性的唯一來源，請從 `build.gradle` 檔案移除儲存庫中的任何其他區段。如果您有多個儲存庫，Gradle 會依列出的順序搜尋每個儲存庫的相依性。

## 從 CodeCatalyst 擷取外掛程式
<a name="gradle-fetch-plugins"></a>

根據預設，Gradle 會從公有 [Gradle 外掛程式入口網站解析外掛程式](https://plugins.gradle.org/)。下列步驟會將 Gradle 專案設定為從 CodeCatalyst 套件儲存庫解析外掛程式。

**使用 Gradle 從 CodeCatalyst 套件儲存庫擷取外掛程式**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 導覽至您的專案。

1. 在導覽窗格中，選擇 **Packages (套件)**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **Gradle**。

1. 您需要個人存取字符 (PAT) 來向 CodeCatalyst 驗證 Gradle。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 使用存取登入資料更新您的 Gradle 屬性檔案。將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱，並將 *PAT* 取代為您的 CodeCatalyst 個人存取字符。您可以針對 *spaceUsername* 和 *spacePassword* 使用任何值，只要您在下列步驟中使用相同的值。

   ```
   spaceUsername=username
   spacePassword=PAT
   ```

1. 將 `pluginManagement`區塊新增至您的 `settings.gradle` 檔案。`pluginManagement` 區塊必須出現在 中的任何其他陳述式之前`settings.gradle`。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *spaceName* 取代為上一個步驟中使用的名稱值。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   pluginManagement {
       repositories {
           maven {
               name = 'spaceName'
               url = uri('https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/')
               credentials(PasswordCredentials)
           }
       }
   }
   ```

   這將確保 Gradle 從指定的儲存庫解析外掛程式。儲存庫必須設定 Gradle 外掛程式入口網站 (`gradle-plugins-store`) 的上游連線，以便建置可以使用常見的 Gradle 外掛程式。如需詳細資訊，請參閱 [Gradle 文件](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories)。

## 透過 CodeCatalyst 從外部套件儲存庫擷取套件
<a name="gradle-install-public"></a>

您可以透過 CodeCatalyst 儲存庫從公有儲存庫安裝 Maven 套件，方法是使用代表閘道儲存庫的閘道上游連線進行設定。從閘道儲存庫安裝的套件會擷取並儲存在 CodeCatalyst 儲存庫中。

CodeCatalyst 支援下列公有 Maven 套件儲存庫。
+ maven-central-gateway
+ google-android-gateway
+ gradle-plugins-gateway
+ commonsware-gateway

**從公有 Maven 套件儲存庫安裝套件**

1. 如果您尚未設定 Gradle 與 CodeCatalyst 套件儲存庫，請遵循 [從 CodeCatalyst 擷取相依性](#gradle-fetch-dependencies)或 中的步驟進行設定[從 CodeCatalyst 擷取外掛程式](#gradle-fetch-plugins)。

1. 請確定您的儲存庫已新增您要從 安裝為上游連線的閘道儲存庫。您可以遵循 中的指示[新增上游儲存庫](packages-upstream-repositories-add.md)，然後選擇要新增為上游的公有套件儲存庫來執行此操作。

如需從上游儲存庫請求套件的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

## 將套件發佈至 CodeCatalyst
<a name="gradle-publish-packages"></a>

本節說明如何將以 Gradle Groovy 建置的 Java 程式庫發佈至 CodeCatalyst 儲存庫。

**使用 Gradle Groovy 將套件發佈至 CodeCatalyst 套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **Gradle Groovy**。

1. 您需要個人存取字符 (PAT) 來向 CodeCatalyst 驗證 Gradle。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 使用存取登入資料更新您的 Gradle 屬性檔案。將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱，並將 *PAT* 取代為您的 CodeCatalyst 個人存取字符。您可以針對 *spaceUsername* 和 *spacePassword* 使用任何值，只要您在下列步驟中使用相同的值。

   ```
   spaceUsername=username
   spacePassword=PAT
   ```

1. 將`maven-publish`外掛程式新增至專案`build.gradle`檔案的 `plugins`區段。

   ```
   plugins {
       id 'java-library'
       id 'maven-publish'
   }
   ```

1. 接著，將`publishing`區段新增至專案`build.gradle`檔案。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   publishing {
       publications {
           mavenJava(MavenPublication) {
               groupId = 'group-id'
               artifactId = 'artifact-id'
               version = 'version'
               from components.java
           }
       }
       repositories {
           maven {
               name = 'spaceName'
               url = uri('https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/')
               credentials(PasswordCredentials)
           }
       }
   }
   ```

   `maven-publish` 外掛程式會根據 `publishing` 區段中`version`指定的 `groupId`、 `artifactId`和 產生 POM 檔案。

1. 這些變更為 `build.gradle` 完成後，請執行下列命令來建置專案，並將其上傳至儲存庫。

   ```
   ./gradlew publish
   ```

1. 導覽至 CodeCatalyst 主控台中的套件儲存庫，以檢查套件是否已成功發佈。您應該會在套件儲存庫的**套件**清單中看到套件。

如需詳細資訊，請參閱 Gradle 網站上的這些主題：
+  [建置 Java 程式庫](https://guides.gradle.org/building-java-libraries/) 
+  [將專案發佈為模組](https://docs.gradle.org/current/userguide/publishing_setup.html) 

## 在 IntelliJ IDEA 中執行 Gradle 建置
<a name="gradle-intellij"></a>

您可以在 IntelliJ IDEA 中執行 Gradle 建置，從 CodeCatalyst 提取相依性。若要使用 CodeCatalyst 驗證 Gradle，您必須使用個人存取字符 (PAT)。您可以將 CodeCatalyst PAT 存放在 `gradle.properties`或您選擇的個別檔案。

### 方法 1：將 PAT 放入 `gradle.properties`
<a name="gradle-intellij-gradle-properties"></a>

如果您未使用 `gradle.properties` 檔案，並且可以使用 PAT 覆寫其內容，請使用此方法。如果您使用的是 `gradle.properties`，您可以修改此方法來新增 PAT，而不是覆寫檔案的內容。

**注意**  
此範例顯示位於 中的 `gradle.properties` 檔案`GRADLE_USER_HOME`。

首先，如果您沒有 PAT，請建立 PAT。

**建立個人存取字符 (PAT)**

1. 在頂端選單列中，選擇您的設定檔徽章，然後選擇**我的設定**。
**提示**  
您也可以前往專案或空間的成員頁面，並從成員清單中選擇您的名稱，以尋找您的使用者設定檔。

1. 在 **PAT 名稱**中，輸入 PAT 的描述性名稱。

1. 在**過期日期**中，保留預設日期或選擇行事曆圖示以選取自訂日期。過期日期預設為目前日期的一年後。

1. 選擇**建立**。

   您也可以在為來源**儲存庫選擇複製**儲存庫時建立此字符。

1. 將 PAT 秘密儲存在安全的位置。
**重要**  
PAT 秘密只會顯示一次。關閉視窗後就無法擷取它。

接著，使用下列程式碼片段更新您的`build.gradle`檔案：

```
repositories {
    maven {
        name = 'spaceName'
        url = uri('https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/')
        credentials(PasswordCredentials)
    }
}
```

### 方法 2：將 PAT 放在單獨的檔案中
<a name="gradle-intellij-file"></a>

如果您不想修改`gradle.properties`檔案，請使用此方法。

首先，如果您沒有 PAT，請建立 PAT。

**建立個人存取字符 (PAT)**

1. 在頂端選單列中，選擇您的設定檔徽章，然後選擇**我的設定**。
**提示**  
您也可以前往專案或空間的成員頁面，並從成員清單中選擇您的名稱，以尋找您的使用者設定檔。

1. 在 **PAT 名稱**中，輸入 PAT 的描述性名稱。

1. 在**過期日期**中，保留預設日期或選擇行事曆圖示以選取自訂日期。過期日期預設為目前日期的一年後。

1. 選擇**建立**。

   您也可以在為來源**儲存庫選擇複製**儲存庫時建立此字符。

1. 將 PAT 秘密儲存在安全的位置。
**重要**  
PAT 秘密只會顯示一次。關閉視窗後就無法擷取它。

**將您的 PAT 放入單獨的檔案中**

1. 使用以下程式碼片段更新您的`build.gradle`檔案。將 *space\$1name*、*proj\$1name* 和 *repo\$1name* 取代為您的 CodeCatalyst 使用者名稱、空格名稱、專案名稱和套件儲存庫名稱。

   ```
   def props = new Properties()
   file("fileName").withInputStream { props.load(it) }
                     
   repositories {
           maven {
               name = 'spaceName'
               url = uri('https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/')
               credentials(PasswordCredentials)
           }
       }
   }
   ```

1. 將您的 PAT 寫入檔案中指定的`build.gradle`檔案：

   ```
   echo "codecatalystArtifactsToken=PAT" > fileName
   ```

# 設定和使用 mvn
<a name="packages-maven-mvn"></a>

您可以使用 `mvn`命令來執行 Maven 組建。您必須`mvn`將 設定為使用套件儲存庫，並提供個人存取字符 (PAT) 進行身分驗證。

**Contents**
+ [從 CodeCatalyst 擷取相依性](#mvn-fetch-dependencies)
+ [透過 CodeCatalyst 從外部套件儲存庫擷取套件](#mvn-install-public)
+ [將套件發佈至 CodeCatalyst](#mvn-publish-packages)
+ [發佈第三方套件](#publishing-third-party-packages)

## 從 CodeCatalyst 擷取相依性
<a name="mvn-fetch-dependencies"></a>

若要`mvn`設定 從 CodeCatalyst 儲存庫擷取相依性，您必須編輯 Maven 組態檔案，`settings.xml`以及選擇性地編輯專案的專案模型物件 (POM) 檔案。POM 檔案包含 Maven 建置專案的專案和組態資訊，例如相依性、建置目錄、來源目錄、測試來源目錄、外掛程式和目標。

**使用 `mvn` 從 CodeCatalyst 套件儲存庫擷取相依性**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **mvn**。

1. 您需要個人存取字符 (PAT) 來`mvn`驗證 CodeCatalyst。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 將包含儲存庫的設定檔新增至 `settings.xml` 檔案。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   <profiles>
     <profile>
       <id>repo_name</id>
       <activation>
           <activeByDefault>true</activeByDefault>
       </activation>
       <repositories>
           <repository>
             <id>repo_name</id>
             <url>https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/</url>
           </repository>
       </repositories>
     </profile>
   </profiles>
   ```

1. 將伺服器新增至 `settings.xml` 檔案中的伺服器清單。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。
   + 將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱。
   + 將 *PAT* 取代為您的 CodeCatalyst PAT。

   ```
   <servers>
     <server>
       <id>repo_name</id>
       <username>username</username>
       <password>PAT</password>
     </server>
   </servers>
   ```

1. （選用） 在`settings.xml`檔案中設定鏡像，擷取所有連線並將其路由到您的儲存庫，而非閘道儲存庫。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   <mirrors>
     <mirror>
       <id>repo_name</id>
       <name>repo_name</name>
       <url>https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/</url>
       <mirrorOf>*</mirrorOf>
     </mirror>
   </mirrors>
   ```

**重要**  
您可以在 `<id>`元素中使用任何值，但在 `<server>`和 `<repository>`元素中必須相同。這可讓指定的登入資料包含在對 CodeCatalyst 的請求中。

進行這些組態變更後，您可以建置專案。

```
mvn compile
```

## 透過 CodeCatalyst 從外部套件儲存庫擷取套件
<a name="mvn-install-public"></a>

您可以透過 CodeCatalyst 儲存庫從公有儲存庫安裝 Maven 套件，方法是使用代表閘道儲存庫的閘道上游連線進行設定。從閘道儲存庫安裝的套件會擷取並儲存在 CodeCatalyst 儲存庫中。

目前，CodeCatalyst 支援下列公有 Maven 套件儲存庫。
+ maven-central-gateway
+ google-android-gateway
+ gradle-plugins-gateway
+ commonsware-gateway

**從公有 Maven 套件儲存庫安裝套件**

1. 如果您尚未設定 ，請依照中的步驟`mvn`，使用 CodeCatalyst 套件儲存庫進行設定[從 CodeCatalyst 擷取相依性](#mvn-fetch-dependencies)。

1. 確保您的儲存庫已新增您要從 安裝的閘道儲存庫做為上游連線。若要檢查要新增哪些上游來源，或將閘道儲存庫新增為上游來源，請遵循 中的指示[新增上游儲存庫](packages-upstream-repositories-add.md)。

如需從上游儲存庫請求套件的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

## 將套件發佈至 CodeCatalyst
<a name="mvn-publish-packages"></a>

若要將 Maven 套件發佈`mvn`至 CodeCatalyst 儲存庫，您還必須編輯 `~/.m2/settings.xml`和專案 POM。

**使用 `mvn`將套件發佈至 CodeCatalyst 套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **mvn**。

1. 您需要個人存取字符 (PAT) 來`mvn`驗證 CodeCatalyst。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 使用 PAT 在本機電腦上設定 環境變數。您將在 `setting.xml` 檔案中使用此環境變數。

   ```
   export CODECATALYST_ARTIFACTS_TOKEN=your_PAT
   ```

1. 使用 `CodeCatalyst_ARTIFACTS_TOKEN`環境變數的`settings.xml`參考將`<servers>`區段新增至 ，讓 Maven 在 HTTP 請求中傳遞字符。

   ```
   <settings>
   ...
       <servers>
           <server>
               <id>repo-name</id>
               <username>username</username>
               <password>${env.CodeCatalyst_ARTIFACTS_TOKEN}</password>
           </server>
       </servers>
   ...
   </settings>
   ```

1. 將`<distributionManagement>`區段新增至專案的 `pom.xml`。

   ```
   <project>
   ...
        <distributionManagement>
            <repository>
                <id>repo_name</id>
                <name>repo_name</name>
                <url>https://packages.region.codecatalyst.aws/maven/space_name/proj_name/repo_name/</url>
            </repository>
        </distributionManagement>
   ...
   </project>
   ```

進行這些組態變更後，您可以建置專案並將其發佈至指定的儲存庫。

```
mvn deploy
```

您可以在 CodeCatalyst 主控台中導覽至套件儲存庫，以檢查套件是否已成功發佈。

## 發佈第三方套件
<a name="publishing-third-party-packages"></a>

您可以使用 將第三方 Maven 套件發佈至 CodeCatalyst 儲存庫`mvn deploy:deploy-file`。這對於想要發佈套件且只有 JAR 檔案且無法存取套件原始碼或 POM 檔案的使用者很有幫助。

`mvn deploy:deploy-file` 命令會根據在命令列中傳遞的資訊產生 POM 檔案。

首先，如果您沒有 PAT，請建立 PAT。

**建立個人存取字符 (PAT)**

1. 在頂端選單列中，選擇您的設定檔徽章，然後選擇**我的設定**。
**提示**  
您也可以前往專案或空間的成員頁面，並從成員清單中選擇您的名稱，以尋找您的使用者設定檔。

1. 在 **PAT 名稱**中，輸入 PAT 的描述性名稱。

1. 在**過期日期**中，保留預設日期或選擇行事曆圖示以選取自訂日期。過期日期預設為目前日期的一年後。

1. 選擇**建立**。

   您也可以在為來源**儲存庫選擇複製**儲存庫時建立此字符。

1. 將 PAT 秘密儲存在安全的位置。
**重要**  
PAT 秘密只會顯示一次。關閉視窗後就無法擷取它。

**發佈第三方 Maven 套件**

1. 建立具有下列內容`~/.m2/settings.xml`的檔案：

   ```
   <settings>
       <servers>
           <server>
               <id>repo_name</id>
               <username>username</username>
               <password>PAT}</password>
           </server>
       </servers>
   </settings>
   ```

1. 執行 `mvn deploy:deploy-file` 命令：

   ```
   mvn deploy:deploy-file -DgroupId=commons-cli          \
   -DartifactId=commons-cli       \
   -Dversion=1.4                  \
   -Dfile=./commons-cli-1.4.jar   \
   -Dpackaging=jar                \
   -DrepositoryId=repo-name      \
   -Durl=https://packages.region.codecatalyst.aws/maven/space-name/proj-name/repo-name/
   ```
**注意**  
上述範例會發佈 `commons-cli 1.4`。修改 groupId、 artifactID、版本和檔案引數以發佈不同的 JAR。

這些指示是根據指南中的範例[，從 Apache Maven 文件將第三方 JARs 部署到遠端儲存庫](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html)。 **

 如需詳細資訊，請參閱 Apache Maven 專案網站上的這些主題：
+  [設定多個儲存庫](https://maven.apache.org/guides/mini/guide-multiple-repositories.html) 
+  [設定參考](https://maven.apache.org/settings.html) 
+  [分佈管理](https://maven.apache.org/pom.html#Distribution_Management) 
+  [設定檔](https://maven.apache.org/pom.html#Profiles) 

# 使用 curl 發佈套件
<a name="packages-maven-curl"></a>

本節說明如何使用 HTTP `curl` 用戶端將 Maven 套件發佈至 CodeCatalyst 套件儲存庫。如果您沒有或想要在環境中安裝 Maven 用戶端，使用 發佈套件`curl`會很有用。

**使用 發佈 Maven 套件 `curl`**

1. 您必須將個人存取字符 (PAT) 存放在環境變數中，以`curl`使用 CodeCatalyst 進行驗證。如果您已經有，則可以使用它。如果沒有，您可以建立一個 並設定環境變數。

   1. 依照中的步驟建立 PAT[使用個人存取權杖授予使用者儲存庫存取權](ipa-tokens-keys.md)。複製 PAT 以將其存放在 環境變數中。

   1. 在本機機器的命令列上，使用 PAT 設定 環境變數。

      ```
      export CodeCatalyst_ARTIFACTS_TOKEN=your_PAT
      ```

1. 使用下列`curl`命令將 JAR 發佈至 CodeCatalyst 儲存庫。以您的 CodeCatalyst 使用者名稱、空格名稱、專案名稱和套件儲存庫名稱取代 *username*、*space\$1name*、*proj*\$1name 和 *repo\$1*name。

   ```
   curl --request PUT https://packages.region.codecatalyst.aws/maven/space-name/proj-name/repo-name/com/mycompany/app/my-app/1.0/my-app-1.0.jar \
        --user "username:CodeCatalyst_ARTIFACTS_TOKEN" --header "Content-Type: application/octet-stream" \
        --data-binary @target/path/to/my-app-1.0.jar
   ```

1. 使用下列`curl`命令將 POM 發佈至 CodeCatalyst 儲存庫。將 *username*、*space\$1name*、*proj\$1name* 和 *repo\$1name* 取代為您的 CodeCatalyst 使用者名稱、空格名稱、專案名稱和套件儲存庫名稱。

   ```
   curl --request PUT https://packages.region.codecatalyst.aws/maven/space-name/proj-name/repo-name/com/mycompany/app/my-app/1.0/my-app-1.0.pom \
        --user "username:CodeCatalyst_ARTIFACTS_TOKEN" --header "Content-Type: application/octet-stream" \
        --data-binary @target/my-app-1.0.pom
   ```

1. 此時，Maven 套件將位於您的 CodeCatalyst 儲存庫中，狀態為 `Unfinished`。若要能夠使用套件，它必須處於 `Published` 狀態。您可以透過將`maven-metadata.xml`檔案`Unfinished``Published`上傳至您的套件，或在 CodeCatalyst 主控台中變更狀態，將套件從 移至 。

   1.  選項 1：使用下列`curl`命令將`maven-metadata.xml`檔案新增至您的套件。以您的 CodeCatalyst 使用者名稱、空格名稱、專案名稱和套件儲存庫名稱取代 *username*、*space\$1name*、*proj*\$1name 和 *repo\$1*name。

      ```
      curl --request PUT https://packages.region.codecatalyst.aws/maven/space-name/proj-name/repo-name/com/mycompany/app/my-app/maven-metadata.xml \
           --user "username:CodeCatalyst_ARTIFACTS_TOKEN" --header "Content-Type: application/octet-stream" \
           --data-binary @target/maven-metadata.xml
      ```

      以下是`maven-metadata.xml`檔案內容的範例：

      ```
      <metadata modelVersion="1.1.0">
          <groupId>com.mycompany.app</groupId>
          <artifactId>my-app</artifactId>
          <versioning>
              <latest>1.0</latest>
              <release>1.0</release>
              <versions>
                  <version>1.0</version>
              </versions>
              <lastUpdated>20200731090423</lastUpdated>
          </versioning>
      </metadata>
      ```

   1.  選項 2：`Published`在 CodeCatalyst 主控台中將套件狀態更新為 。如需如何更新套件版本狀態的資訊，請參閱 [更新套件版本的狀態](working-with-packages-update-version-status.md)。

如果您只有套件的 JAR 檔案，您可以使用 將消耗性套件版本發佈至 CodeCatalyst 儲存庫`mvn`。如果您無法存取套件的原始碼或 POM，這會很有用。如需詳細資訊，請參閱 [發佈第三方套件](packages-maven-mvn.md#publishing-third-party-packages)。

# 使用 Maven 檢查總和和和快照
<a name="packages-maven-checksums-snapshots"></a>

下列各節說明如何在 CodeCatalyst 中使用 Maven 檢查總和和和 Maven 快照。

## 使用 Maven 檢查總和
<a name="maven-checksums"></a>

 當 Maven 套件發佈至 CodeCatalyst 套件儲存庫時，與套件中每個*資產*或檔案相關聯的檢查總和會用來驗證上傳。資產的範例包括 *jar*、*pom* 和 *war* 檔案。對於每個資產，Maven 套件包含多個檢查總和檔案，這些檔案使用資產名稱搭配額外的副檔名，例如 `md5`或 `sha1`。例如，名為 的檔案檢查總和檔案`my-maven-package.jar`可能是 `my-maven-package.jar.md5`和 `my-maven-package.jar.sha1`。

 每個 Maven 套件也都包含 `maven-metadata.xml` 檔案。必須上傳此檔案，發佈才能成功。如果在上傳任何套件檔案期間偵測到檢查總和不相符，發佈會停止。這可能會導致 `maven-metadata.xml` 無法上傳。發生這種情況時，Maven 套件的狀態會設為 `Unfinished`。您無法下載屬於具有此狀態之套件的資產。

當您發佈 Maven 套件時，如果檢查總和不相符，請記住下列事項：
+  如果在`maven-metadata.xml`上傳之前發生檢查總和不相符，則套件的狀態不會設為 `Unfinished`。套件不會顯示，也無法使用其資產。發生這種情況時，請嘗試下列其中一項，然後再次嘗試下載資產。
  + 執行再次發佈 Maven 套件的 命令。如果網路問題在下載期間損毀檢查總和檔案，這可能會起作用。如果已解決重試的網路問題，檢查總和會相符且下載成功。
  +  如果重新發佈 Maven 套件無法運作，請刪除套件，然後重新發佈套件。
+  如果在`maven-metadata.xml`上傳之後發生檢查總和不相符，套件的狀態會設為 `Published`。您可以取用套件中的任何資產，包括檢查總和不相符的資產。當您下載資產時，CodeCatalyst 產生的檢查總和會隨之下載。如果下載的檔案與檢查總和不相符相關聯，則其下載的檢查總和檔案可能與發佈套件時上傳的檢查總和不相符。

## 使用 Maven 快照
<a name="maven-snapshots"></a>

 Maven *快照*是 Maven 套件的特殊版本，參考最新的生產分支程式碼。這是最終發行版本之前的開發版本。您可以透過`SNAPSHOT`附加到套件版本的尾碼來識別 Maven 套件的快照版本。例如， 版本的快照`1.1`為 `1.1-SNAPSHOT`。如需詳細資訊，請參閱[什麼是 SNAPSHOT 版本？](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) Apache Maven 專案網站上的 。

 CodeCatalyst 支援發佈和使用 Maven 快照。您可以將 Maven 快照發佈到 CodeCatalyst 儲存庫，或者，如果您直接連接到上游儲存庫。不過，不支援套件儲存庫和其中一個上游儲存庫中的快照版本。例如，如果您將具有 版本的 Maven 套件上傳`1.2-SNAPSHOT`到套件儲存庫，CodeCatalyst 不支援將具有相同快照版本的 Maven 套件上傳到其其中一個上游儲存庫。此案例可能會傳回無法預測的結果。

 發佈 Maven 快照時，其先前版本會保留在稱為*組建*的新版本中。每次發佈 Maven 快照時，都會建立新的建置版本。所有舊版的快照都會保留在其建置版本中。發佈 Maven 快照時，其狀態會設為 ，`Published`而包含先前版本的組建狀態會設為 `Unlisted`。

 如果您請求快照，`Published`則會傳回狀態為 的版本。這一律是 Maven 快照的最新版本。您也可以請求特定建置快照。

若要刪除 Maven 快照的所有建置版本，請使用 CodeCatalyst 主控台。

# 使用 NuGet
<a name="packages-nuget"></a>

這些主題說明如何使用 CodeCatalyst 來使用和發佈`NuGet`套件。

**注意**  
CodeCatalyst 支援 [NuGet 4.8 版和更新版本。](https://docs.microsoft.com/en-us/nuget/release-notes/nuget-4.8-rtm)

**Topics**
+ [搭配 Visual Studio 使用 CodeCatalyst](packages-nuget-visual-studio.md)
+ [設定和使用 nuget 或 dotnet CLI](packages-nuget-cli.md)
+ [NuGet 套件名稱、版本和資產名稱標準化](nuget-name-normalization.md)
+ [NuGet 相容性](packages-nuget-compatibility.md)

# 搭配 Visual Studio 使用 CodeCatalyst
<a name="packages-nuget-visual-studio"></a>

 您可以直接在 Visual Studio 中使用 CodeCatalyst 的套件。

若要設定和使用 NuGet 搭配 CLI 工具，例如 `dotnet`或 `nuget`，請參閱 [設定和使用 nuget 或 dotnet CLI](packages-nuget-cli.md)。

**Contents**
+ [使用 CodeCatalyst 設定 Visual Studio](#packages-nuget-vs-configure)
  + [Windows](#packages-nuget-vs-configure-windows)
  + [macOS](#packages-nuget-vs-configure-mac)

## 使用 CodeCatalyst 設定 Visual Studio
<a name="packages-nuget-vs-configure"></a>

### Windows
<a name="packages-nuget-vs-configure-windows"></a>

**使用 CodeCatalyst 設定 Visual Studio**

1. 需要個人存取字符 (PAT) 才能向 CodeCatalyst 進行身分驗證。如果您已經有，則可以使用它。如果沒有，請遵循 中的指示[使用個人存取權杖授予使用者儲存庫存取權](ipa-tokens-keys.md)建立一個。

1. 使用 `nuget`或 `dotnet` 來設定套件儲存庫和登入資料。

------
#### [ dotnet ]

   **Linux 和 macOS 使用者：**由於非 Windows 平台不支援加密，您必須將 `--store-password-in-clear-text`旗標新增至下列命令。請注意，這會將您的密碼以純文字形式存放在您的組態檔案中。

   ```
   dotnet nuget add source https://packages.region.codecatalyst.aws/nuget/space-name/proj-name/repo-name/v3/index.json --name repo_name --password PAT --username user_name
   ```

------
#### [ nuget ]

   ```
   nuget sources add -name repo_name -Source https://packages.region.codecatalyst.aws/nuget/space-name/proj-name/repo-name/v3/index.json -password PAT --username user_name
   ```

------

   輸出範例：

   ```
   Package source with Name: repo_name added successfully.
   ```

1. 設定 Visual Studio 以使用您的新套件來源。在 Visual Studio 中，選擇**工具**，然後選擇**選項**。

1. 在**選項**選單中，展開 **NuGet Package Manager** 區段，然後選擇**套件來源**。

1. 在**可用套件來源**清單中，確認您的 *repo\$1name* 來源已啟用。如果您已使用 NuGet Gallery 的上游連線設定套件儲存庫，請停用 **nuget.org** 來源 。

### macOS
<a name="packages-nuget-vs-configure-mac"></a>

**使用 CodeCatalyst 設定 Visual Studio**

1. 需要個人存取字符 (PAT) 才能向 CodeCatalyst 進行身分驗證。如果您已經有，則可以使用它。如果沒有，請遵循 中的指示[使用個人存取權杖授予使用者儲存庫存取權](ipa-tokens-keys.md)建立一個。

1. 從選單列選擇**偏好設定**。

1. 在 **NuGet** 區段中，選擇**來源**。

1. 選擇**新增**並新增您的儲存庫資訊。

   1. 在**名稱**中，輸入您的 CodeCatalyst 套件儲存庫名稱。

   1. 在**位置**中，輸入您的 CodeCatalyst 套件儲存庫端點。下列程式碼片段顯示範例端點。以您的 CodeCatalyst 空間名稱、專案名稱和儲存庫名稱取代 *space-name*、*proj-name* 和 *repo-*name。

      ```
      https://packages.region.codecatalyst.aws/nuget/space-name/proj-name/repo-name/
      ```

   1. 針對**使用者名稱**，輸入任何有效的值。

   1. 針對**密碼**，輸入您的 PAT。

1. 選擇 **Add source (新增來源)**。

1. 如果您已使用 NuGet Gallery 的上游連線設定套件儲存庫，請停用 **nuget.org** 來源。

組態之後，如果您已將 CodeCatalyst 儲存庫、任何上游儲存庫或 [NuGet.org](https://www.nuget.org/) 設定為上游來源，則 Visual Studio 可以使用其套件。如需有關在 Visual Studio 中瀏覽和安裝 NuGet 套件的詳細資訊，請參閱 *NuGet 文件 NuGet*中的[使用 NuGet Package Manager 在 Visual Studio 中安裝和管理套件](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-visual-studio)。

# 設定和使用 nuget 或 dotnet CLI
<a name="packages-nuget-cli"></a>

您可以使用 CLI 工具`dotnet`，例如 `NuGet`和 從 CodeCatalyst 發佈和使用套件。本文件提供有關設定 CLI 工具以及使用它們來發佈或取用套件的資訊。

**Contents**
+ [使用 CodeCatalyst 設定 NuGet](#nuget-configure-cli)
+ [從 CodeCatalyst 儲存庫取用 NuGet 套件](#nuget-consume-cli)
+ [透過 CodeCatalyst 從 NuGet.org 取用 NuGet 套件](#nuget-consume-nuget-gallery)
+ [將 NuGet 套件發佈至 CodeCatalyst](#nuget-publish-cli)

## 使用 CodeCatalyst 設定 NuGet
<a name="nuget-configure-cli"></a>

若要使用 CodeCatalyst 設定 NuGet，請將儲存庫端點和個人存取字符新增至 NuGet 組態檔案，以允許 `nuget`或 `dotnet` 連線至 CodeCatalyst 套件儲存庫。

**使用 CodeCatalyst 套件儲存庫設定 NuGet**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **NuGet** 或 **dotnet**。

1. 您需要個人存取字符 (PAT) 來使用 CodeCatalyst 驗證 NuGet。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 設定 `nuget`或 `dotnet`以使用儲存庫的 NuGet 端點和 CodeCatalyst PAT。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱。
   + 將 *PAT* 取代為您的 CodeCatalyst PAT。
   + 以您的 CodeCatalyst 空間名稱取代 *space\$1name*。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   1. 若是 `nuget`，則使用 `nuget sources add` 命令。

      ```
      nuget sources add -name "repo_name" -Source "https://packages.region.codecatalyst.aws/nuget/space_name/proj_name/repo_name/v3/index.json" -username "username" -password "PAT"
      ```

   1. 若是 `dotnet`，則使用 `dotnet nuget add source` 命令。

      **Linux 和 macOS 使用者**：由於非 Windows 平台不支援加密，您必須將 `--store-password-in-clear-text`旗標新增至下列命令。請注意，這會將您的密碼以純文字形式存放在您的組態檔案中。

      ```
      dotnet nuget add source "https://packages.region.codecatalyst.aws/nuget/space_name/proj_name/repo_name/v3/index.json" -n "proj_name/repo_name" -u "username" -p "PAT" --store-password-in-clear-text
      ```

使用 CodeCatalyst 設定 NuGet 後，您可以[取用儲存在 CodeCatalyst 儲存庫或其其中一個上游儲存庫中的 NuGet 套件](#nuget-consume-cli)，並將 [ NuGet 套件發佈](#nuget-publish-cli)到您的 CodeCatalyst 儲存庫。 CodeCatalyst 

## 從 CodeCatalyst 儲存庫取用 NuGet 套件
<a name="nuget-consume-cli"></a>

[使用 CodeCatalyst 設定 NuGet ](#nuget-configure-cli)後，您可以使用儲存在 CodeCatalyst 儲存庫或其中一個上游儲存庫中的 NuGet 套件。

若要使用 CodeCatalyst 儲存庫或其中一個具有 nuget 或 dotnet 的上游儲存庫的套件版本，請執行下列命令。將 *packageName* 取代為您想要使用的套件名稱，並將 *packageSourceName* 取代為 NuGet 組態檔案中 CodeCatalyst 套件儲存庫的來源名稱，該名稱應為儲存庫名稱。

**使用 安裝套件 `dotnet`**

```
dotnet add packageName --source packageSourceName
```

**使用 安裝套件 `nuget`**

```
nuget install packageName --source packageSourceName
```

如需詳細資訊，請參閱 *Microsoft 文件*中的[使用 nuget CLI 管理套件](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-nuget-cli)，或使用 [dotnet CLI 安裝和管理套件](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-dotnet-cli)。

## 透過 CodeCatalyst 從 NuGet.org 取用 NuGet 套件
<a name="nuget-consume-nuget-gallery"></a>

您可以透過 CodeCatalyst 儲存庫從 [NuGet.org](https://www.nuget.org/) 使用 NuGet 套件，方法是設定儲存庫與 **NuGet.org** 的上游連線。從 **NuGet.org** 取用的套件會擷取並儲存在 CodeCatalyst 儲存庫中。

**從 NuGet.org 取用套件**

1. 如果您尚未設定 NuGet 套件管理員與 CodeCatalyst 套件儲存庫，請遵循中的步驟進行設定[使用 CodeCatalyst 設定 NuGet](#nuget-configure-cli)。

1. 請確定您的儲存庫已新增 **NuGet.org** 做為上游連線。您可以依照 中的指示[新增上游儲存庫](packages-upstream-repositories-add.md)並選擇 **NuGet 儲存**庫，來檢查要新增哪些上游來源，或新增 **Nuget.org** 做為上游來源。

## 將 NuGet 套件發佈至 CodeCatalyst
<a name="nuget-publish-cli"></a>

[使用 CodeCatalyst 設定 NuGet ](#nuget-configure-cli)後，您可以使用 `nuget`或 `dotnet`將套件版本發佈至 CodeCatalyst 儲存庫。

若要將套件版本推送至 CodeCatalyst 儲存庫，請在 NuGet 組態`.nupkg`檔案中執行下列命令，其中包含檔案的完整路徑和 CodeCatalyst 儲存庫的來源名稱。

**使用 發佈套件 `dotnet`**

```
dotnet nuget push path/to/nupkg/SamplePackage.1.0.0.nupkg --source packageSourceName
```

**使用 發佈套件 `nuget`**

```
nuget push path/to/nupkg/SamplePackage.1.0.0.nupkg --source packageSourceName
```

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

CodeCatalyst 會在儲存套件之前將套件和資產名稱和套件版本標準化，這表示 CodeCatalyst 中的名稱或版本可能與發佈套件或資產時提供的名稱或版本不同。

**套件名稱標準化：**CodeCatalyst 透過將所有字母轉換為小寫來標準化 NuGet 套件名稱。

**套件版本標準化：**CodeCatalyst 使用與 NuGet 相同的模式標準化 NuGet 套件版本。以下資訊來自 NuGet 文件的[標準化版本編號](https://docs.microsoft.com/en-us/nuget/concepts/package-versioning#normalized-version-numbers)。
+ 前導零會從版本編號中移除：
  + `1.00` 視為 `1.0`
  + `1.01.1` 會被視為 `1.1.1`
  + `1.00.0.1` 視為 `1.0.0.1`
+ 版本編號的第四部分會省略零：
  + `1.0.0.0` 視為 `1.0.0`
  + `1.0.01.0` 視為 `1.0.1`
+ SemVer 2.0.0 建置中繼資料已移除：
  + `1.0.7+r3456` 視為 `1.0.7`

**套件資產名稱標準化：**CodeCatalyst 會從標準化套件名稱和套件版本建構 NuGet 套件資產名稱。

# NuGet 相容性
<a name="packages-nuget-compatibility"></a>

 本指南包含 CodeCatalyst 與不同 NuGet 工具和版本相容性的相關資訊。

**Topics**
+ [一般 NuGet 相容性](#nuget-version-support)
+ [NuGet 命令列支援](#nuget-command-line-support)

## 一般 NuGet 相容性
<a name="nuget-version-support"></a>

CodeCatalyst 支援 NuGet 4.8 及更高版本。

CodeCatalyst 僅支援 NuGet HTTP 通訊協定的 V3。這表示不支援某些依賴通訊協定 V2 的 CLI 命令。如需詳細資訊，請參閱下[nuget 命令支援](#nuget-command-support)一節。

CodeCatalyst 不支援 PowerShellGet 2.x。

## NuGet 命令列支援
<a name="nuget-command-line-support"></a>

CodeCatalyst 支援 NuGet (`nuget`) 和 .NET Core (`dotnet`) CLI 工具。

### nuget 命令支援
<a name="nuget-command-support"></a>

由於 CodeCatalyst 僅支援 NuGet HTTP 通訊協定的 V3，因此針對 CodeCatalyst 資源使用時，下列命令將無法運作：
+ `list`： `nuget list`命令會顯示來自指定來源的套件清單。若要取得 CodeCatalyst 套件儲存庫中的套件清單，請導覽至 CodeCatalyst 主控台中的儲存庫。

# 使用 Python
<a name="packages-python"></a>

這些主題說明如何搭配 CodeCatalyst 使用 `pip`、Python 套件管理員`twine`和 Python 套件發佈公用程式。

**Topics**
+ [設定 pip 和安裝 Python 套件](packages-python-pip.md)
+ [設定 Twine 和發佈 Python 套件](packages-python-twine.md)
+ [Python 套件名稱標準化](python-name-normalization.md)
+ [Python 相容性](packages-python-compatibility.md)

# 設定 pip 和安裝 Python 套件
<a name="packages-python-pip"></a>

若要`pip`搭配 CodeCatalyst 使用 ，您必須`pip`連線至套件儲存庫，並提供個人存取字符以進行身分驗證。您可以在 CodeCatalyst 主控台中檢視`pip`連線至套件儲存庫的指示。驗證並`pip`連線至 CodeCatalyst 後，您可以執行`pip`命令。

**Contents**
+ [使用 pip 從 CodeCatalyst 安裝 Python 套件](#pip-install)
+ [透過 CodeCatalyst 從 PyPI 取用 Python 套件](#pip-install-pypi)
+ [pip 命令支援](#pip-command-support)
  + [支援與儲存庫互動的命令](#supported-pip-commands-that-interact-with-a-repository)
  + [支援的用戶端命令](#supported-pip-client-side-commands)

## 使用 pip 從 CodeCatalyst 安裝 Python 套件
<a name="pip-install"></a>

下列指示說明如何`pip`設定 從 CodeCatalyst 套件儲存庫或其中一個上游儲存庫安裝 Python 套件。

**設定和使用 從 CodeCatalyst 套件儲存庫`pip`安裝 Python 套件**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **pip**。

1. 您需要個人存取字符 (PAT) 來驗證 CodeCatalyst 的 pip。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 使用 `pip config`命令來設定 CodeCatalyst 登錄 URL 和登入資料。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
   + 將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱。
   + 將 *PAT* 取代為您的 CodeCatalyst PAT。
   + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
   + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
   + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

   ```
   pip config set global.index-url https://username:PAT@https://packages.region.codecatalyst.aws/pypi/space_name/proj_name/repo_name/simple/
   ```

1. 假設您的儲存庫或其中一個上游儲存庫中有套件，您可以使用 安裝套件`pip install`。例如，使用下列命令來安裝 `requests`套件。

   ```
   pip install requests
   ```

   使用 `-i`選項暫時還原為從 [https://pypi.org](https://pypi.org) 安裝套件，而非 CodeCatalyst 套件儲存庫。

   ```
   pip install -i https://pypi.org/simple requests
   ```

## 透過 CodeCatalyst 從 PyPI 取用 Python 套件
<a name="pip-install-pypi"></a>

您可以透過 CodeCatalyst 儲存庫從 Python [套件索引 (PyPI)](https://www.pypi.org/) 使用 Python 套件，方法是使用上游連線至 **PyPI** 的儲存庫。從 **PyPI** 取用的套件會擷取並儲存在 CodeCatalyst 儲存庫中。

**從 PyPI 取用套件**

1. 如果您尚未設定，請依照中的步驟，使用 CodeCatalyst 套件儲存庫設定 pip[使用 pip 從 CodeCatalyst 安裝 Python 套件](#pip-install)。

1. 請確定您的儲存庫已新增 **PyPI** 做為上游來源。您可以依照 中的指示[新增上游儲存庫](packages-upstream-repositories-add.md)並選擇 **PyPI** **儲存庫，來檢查要新增哪些上游來源，或新增 PyPI ** 做為上游來源。

如需從上游儲存庫請求套件的詳細資訊，請參閱 [使用上游儲存庫請求套件版本](packages-upstream-repositories-request.md)。

## pip 命令支援
<a name="pip-command-support"></a>

下列各節摘要說明 CodeCatalyst 儲存庫支援的 pip 命令，以及不支援的特定命令。

**Topics**
+ [支援與儲存庫互動的命令](#supported-pip-commands-that-interact-with-a-repository)
+ [支援的用戶端命令](#supported-pip-client-side-commands)

### 支援與儲存庫互動的命令
<a name="supported-pip-commands-that-interact-with-a-repository"></a>

本節列出 `pip` 命令，其中`pip`用戶端會對其設定的登錄提出一或多個請求。已驗證這些命令在針對 CodeCatalyst 套件儲存庫調用時可正常運作。


****  

| 命令 | Description | 
| --- | --- | 
|   [安裝](https://pip.pypa.io/en/stable/reference/pip_install/)   |  安裝套件。  | 
|   [下載](https://pip.pypa.io/en/stable/reference/pip_download/)   |  下載套件。  | 

CodeCatalyst 不會實作 `pip search`。如果您已`pip`設定 CodeCatalyst 套件儲存庫，執行 `pip search`會搜尋並顯示來自 [PyPI](https://pypi.org/) 的套件。

### 支援的用戶端命令
<a name="supported-pip-client-side-commands"></a>

這些命令不需要與儲存庫進行任何直接互動，因此 CodeCatalyst 不需要執行任何動作來支援儲存庫。


****  

| 命令 | Description | 
| --- | --- | 
|   [解除安裝](https://pip.pypa.io/en/stable/reference/pip_uninstall/)   |  解除安裝套件。  | 
|   [凍結](https://pip.pypa.io/en/stable/reference/pip_freeze/)   |  以要求格式輸出已安裝的套件。  | 
|   [清單](https://pip.pypa.io/en/stable/reference/pip_list/)   |  列出已安裝的套件。  | 
|   [sh](https://pip.pypa.io/en/stable/reference/pip_show/)ow   |  顯示已安裝套件的相關資訊。  | 
|   [檢查](https://pip.pypa.io/en/stable/reference/pip_check/)   |  確認已安裝的套件具有相容的相依性。  | 
|   [組態](https://pip.pypa.io/en/stable/reference/pip_config/)   |  管理本機和全域組態。  | 
|   [滾輪](https://pip.pypa.io/en/stable/reference/pip_wheel/)   |  根據您的需求建置車輪。  | 
|   [雜湊](https://pip.pypa.io/en/stable/reference/pip_hash/)   |  套件封存的運算雜湊。  | 
|   [完成](https://pip.pypa.io/en/stable/user_guide/#command-completion)   |  協助完成命令。  | 
|   [debug](https://pip.pypa.io/en/stable/reference/pip_debug/)   |  顯示適用於偵錯的資訊。  | 
|  說明  |  顯示 命令的說明。  | 

# 設定 Twine 和發佈 Python 套件
<a name="packages-python-twine"></a>

若要`twine`搭配 CodeCatalyst 使用 ，您必須`twine`連線至套件儲存庫，並提供個人存取權杖以進行身分驗證。您可以在 CodeCatalyst 主控台中檢視`twine`連線至套件儲存庫的指示。驗證並`twine`連線至 CodeCatalyst 後，您可以執行`twine`命令。

## 使用 Twine 將套件發佈至 CodeCatalyst
<a name="packages-twine-publish"></a>

下列指示說明如何驗證並`twine`連線至 CodeCatalyst 套件儲存庫。

**設定和使用 `twine`將套件發佈到您的 CodeCatalyst 套件儲存庫**

1. 在 https：//[https://codecatalyst.aws/](https://codecatalyst.aws/) 開啟 CodeCatalyst 主控台。

1. 在專案的概觀頁面上，選擇**套件**。

1. 從套件儲存庫清單中選擇套件儲存庫。

1. 選擇**連線至儲存庫**。

1. 在**連線至儲存庫**對話方塊中，從套件管理員用戶端清單中選擇 **Twine**。

1. 您需要個人存取字符 (PAT) 才能透過 CodeCatalyst 驗證雙身。如果您已經有，則可以使用它。如果沒有，您可以在這裡建立一個。

   1. 選擇**建立權杖**。

   1. 選擇**複製**以複製您的 PAT。
**警告**  
關閉對話方塊後，您將無法再次查看或複製 PAT。

1. 您可以使用 `.pypirc` 檔案或環境變數來設定雙身。

   1. **使用 `.pypirc` 檔案設定 。**

      在您選擇的編輯器`~/.pypirc`中開啟 。

      新增 CodeCatalyst 的索引伺服器，包括您在上一個步驟中建立和複製的儲存庫、使用者名稱和 PAT。取代下列值。
**注意**  
如果從主控台指示複製，則應為您更新下列值，且不應變更。
      + 將*使用者名稱*取代為您的 CodeCatalyst 使用者名稱。
      + 將 *PAT* 取代為您的 CodeCatalyst PAT。
      + 將 *space\$1name* 取代為您的 CodeCatalyst 空間名稱。
      + 將 *proj\$1name* 取代為您的 CodeCatalyst 專案名稱。
      + 將 *repo\$1name* 取代為您的 CodeCatalyst 套件儲存庫名稱。

      ```
      [distutils]
      index-servers = proj-name/repo-name
      
      [proj-name/repo-name]
      repository = https://packages.region.codecatalyst.aws/pypi/space_name/proj_name/repo_name/
      password = PAT
      username = username
      ```

   1. **使用環境變數設定 。**

      設定下列環境變數。在 `TWINE_REPOSITORY_URL`值中，使用 CodeCatalyst 空間、專案和套件儲存庫名稱更新 *space\$1name*、*proj\$1name* 和 *repo\$1name*。

      ```
      export TWINE_USERNAME=username
      ```

      ```
      export TWINE_PASSWORD=PAT
      ```

      ```
      export TWINE_REPOSITORY_URL="https://packages.region.codecatalyst.aws/pypi/space_name/proj_name/repo_name/"
      ```

1. 使用 `twine upload`命令發佈 Python 分佈。

# Python 套件名稱標準化
<a name="python-name-normalization"></a>

CodeCatalyst 會先標準化套件名稱再儲存，這表示 CodeCatalyst 中的套件名稱可能與發佈套件時提供的名稱不同。

對於 Python 套件，執行標準化時，套件名稱會小寫`-`，且字元 `.`、 和 的所有執行個體`_`都會以單一`-`字元取代。因此，套件名稱 `pigeon_cli` 和 `pigeon.cli`會標準化並儲存為 `pigeon-cli`。非標準化名稱可供 pip 和 Twine 使用。如需 Python 套件名稱標準化的詳細資訊，請參閱 Python 文件中的 [PEP 503](https://www.python.org/dev/peps/pep-0503/#normalized-names)。

# Python 相容性
<a name="packages-python-compatibility"></a>

 雖然 CodeCatalyst 不支援 `/simple/` API，但它確實支援 `Legacy` API 操作。CodeCatalyst 不支援 PyPI `XML-RPC`或 `JSON` API 操作。

如需詳細資訊，請參閱 Python Packaging Authority 的 GitHub 儲存庫上的以下內容。
+ [舊版 API](https://warehouse.pypa.io/api-reference/legacy.html)
+ [XML-RPC API](https://github.com/pypi/warehouse/blob/main/docs/dev/api-reference/xml-rpc.rst)
+ [JSON API](https://docs.pypi.org/api/json/)

# 套件的配額
<a name="packages-quotas"></a>

下表說明 Amazon CodeCatalyst 中套件的配額和限制。如需 Amazon CodeCatalyst 中配額的詳細資訊，請參閱 [CodeCatalyst 的配額](quotas.md)。


| 資源 | 預設配額 | 
| --- | --- | 
| 套件儲存庫 | 每個空間最多 1000 個。 | 
| 直接上游儲存庫 |  每個套件儲存庫最多 10 個。  | 
| 搜尋的上游套件儲存庫 |  每個請求的套件版本最多搜尋 25 個上游儲存庫。  | 
| 套件資產檔案大小 |  每個套件資產最多 5GB。  | 
|  套件資產  |  每個套件版本最多 150 個。  | 