介绍

Athens Logo

Athens 是你的 Go Packages 服务器

欢迎,Gophers! 我们期待把 Athens 介绍给你..

在这个站点上,我们详细地记录了 Athens 的细节。我们将会告诉您它都做了什么,它为什么有意义,你可以用它来做什么,以及你如何运行它。下面是简单的概要。

如何开始?

运行 `docker run -p '3000:3000' gomods/athens:latest`

然后,设置你的 GOPROXYgo get 去!

export GOPROXY=http://localhost:3000 && go get module@v1

Athens 做了什么?

Athens 为你运行 Go 模块 提供服务。它可以为你提供公有和私有的代码,因此,你不需要直接从像 GitHub 或 GitLab 等版本控制系统(VCS)上拉取。

它为什么有意义?

你需要代理服务器(如安全性和性能)的原因有很多。看一下这里的描述的。

我如何使用它?

你自己可以轻易地运行起来 Athens.我们给你几个选项:

  • 可以在你的系统上以二进制的方式运行
    • 稍后会有相关指令
  • 你可以用 Docker 镜像的方式来运行(查看这里对如何做的介绍)
  • 你可以在 Kubernetes 上运行它(查看这里对如何做的介绍)

我们还运行了一个体验版本的 Athens,因此你什么都不需要安装也能开始。为此,你需要设置环境变量 GOPROXY="https://athens.azurefd.net".

喜欢你听到的吗?现在尝试一下 Athens 吧!

还没有准备好尝试 Athens?

这里有一些其他的参与方法:

  • 阅读完整的指南,设置、运行并测试 Athens 代理,进行深入地探索。
  • 加入我们的开发者周例会!这是一个很好的方法,与大家见面、提问或者只是旁听。我们欢迎任何人加入并参与。
  • 查看我们的问题列表中的 good first issues
  • Gophers Slack 上的 #athens 频道中加入我们

Athens banner attributed to Golda Manuel

介绍 的子部分

介绍 Athens

欢迎来到 Athens,Gophers!我们在首页上给出了一个非常简洁的 Athens 概览,因此如果你想要了解更多,那么你就来对了地方!

本章将详细阐述 Athens 的功能,意义,以及如何在你的工作流中使用它。

下一步该去哪里

我们建议你从前往后阅读这个章节:

介绍 Athens 的子部分

Athens 101

什么是 Athens?

简而言之,Athens 是一个建立在 vgo(或 go1.11+) 之上的项目,通过它你可以更容易地处理包的依赖问题,即使在 VCS 无法访问的时候,你也可以重新构建你的项目。

Athens 的宏伟目标是提供一个用于存放依赖(而不是代码)的新地方。因为在 GitHub 上,每一份元数据都对应着唯一不变的代码块,所以 Athens 只需要控制原数据的存储就够了。

你可能已经知道“不可变”的意义,但请让我再次说明,因为这一点对整个系统是非常重要的。当小伙伴改变了他们的包,迭代,实验,或者其他的事情,代码在 Athens 中永远不会变。如果包的作者发布了一个新版本,Athens 会把它拉取下来,并展现出来。因此,如果你依赖包 M 的版本 v1.2.3,那么它在 Athens 中就永远不会改变。即使是强制推送或者是删除版本库,这都不会改变

下载协议

Athens 在 Go 命令行接口的基础上建立了一些端点,用来于外部提供模块的代理通信。我们称这些端点为_下载协议_

vgo 在下载协议上的原始调研报告可以在这里找到:https://research.swtch.com/vgo-module

每个端点都对应一个顶层模块。让我们假设模块 htp 是由 acidburn 编写的。

因此,我们下面提到的端点都假设位于 acidburn/htp/@v/{endpoint}(例如:acidburn/htp/@v/list

在下面的例子中,$HOST$PORT 都是 Athens 服务的主机和端口的占位符。

版本列表

这个端点返回 Athens 中模块 acidburn/htp 的版本列表。下面的列表由换行符分割:

GET $HOST:$PORT/github.com/acidburn/htp/@v/list
v0.1.0
v0.1.1
v1.0.0
v1.0.1
v1.2.0

版本信息

GET $HOST:$PORT/github.com/acidburn/htp/@v/v1.0.0.info

这会以 JSON 格式返回关于 v1.0.0 的信息。它看起来像:

{
    "Name": "v1.0.0",
    "Short": "v1.0.0",
    "Version": "v1.0.0",
    "Time": "1972-07-18T12:34:56Z"
}

文件 Go.mod

GET $HOST:$PORT/github.com/acidburn/htp/@v/v1.0.0.mod

这会返回文件 go.mod 的版本 v1.0.0.如果 $HOST:$PORT/github.com/acidburn/htp 的 v1.0.0 版本没有依赖, 那么响应就会像这样:

module github.com/acidburn/htp

模块源

GET $HOST:$PORT/github.com/acidburn/htp/@v/v1.0.0.zip

显而易见——它会把该模块的 v1.0.0 版本的源码以 zip 格式返回。

Latest

GET $HOST:$PORT/github.com/acidburn/htp/@latest

这个端点会返回对应模块的最新版本。如果没有 latest 标签,它会根据最后一次提交的哈希值去找到对应的版本。

为什么Athens重要?

不变性

Go社区的许多问题都是由于库(library)的消失或者在没有告警的情况下突然变化所引起的。上游的软件包维护人员很容易对他们的代码进行更改,但这可能会破坏您的代码,而大多数情况下这是一个意外! 如果您的软件使用的某个依赖项执行下列操作,该软件的构建是否会中断?

  • 提交(Commit) abdef 被删除了
  • 标签(Tag) v0.1.0 被强制推送(push)
  • 源码库被完全删除

由于应用程序的依赖项直接来自VCS(版本控制系统,如Github),因此上述情况都可能发生在您身上,并且当它们发生时,您的软件的构建过程可能会中断-哦,不! Athens通过将代码从VCS复制到_不可变_存储中来解决这些问题。

在这种方式下,您就不需要手动将任何内容上传到Athens后端存储。Go第一次向Athens请求依赖包时,Athens会从VCS(Github、Bitbucket等)获取。但一旦检索到该模块,它将永远保存在Athens的后端存储中,并且代理将不再返回到VCS中获取同一版本的依赖包。这就是雅典如何实现模块不变性。需要注意的是,后端存储掌握在您的手中。

逻辑

go命令行现在可以ping 您自己的服务器 来下载依赖项,这意味着您可以编写任何需要的逻辑来提供这种依赖项。包括访问控制(下面将讨论)、添加自定义版本、自定义分支和自定义包等。例如,Athens提供了一个验证钩子(hook),每个模块下载时都会调用它来确定是否应该下载此模块。因此,您可以用自己的逻辑扩展athens,比如扫描模块路径或代码以查找标红代码等。

性能

从Athens下载存储的依赖关系_显著_比从版本控制系统下载依赖更快。这是因为go get默认情况下使用VCS的下载模块,例如git clone。而go get启用GOPROXY时,将使用HTTP下载zip压缩包。因此,根据您的计算机和网络连接速度,从GitHub下载CockroachDB源代码zip文件只需要10秒,但git clone需要将近4分钟。

访问控制

比软件包消失更糟糕的是,软件包可能是恶意的。为了确保您的团队或公司不会安装此类恶意软件包,当go命令行请求一个被排除的模块(恶意软件)时,您可以让代理服务器返回500。这将导致构建失败,因为Go需要200 HTTP响应码。使用Athens,您可以通过过滤器(filter)文件实现此目的。

Vendor 目录成为可选

有了不变的、高性能和高鲁棒性的代理服务器,用户不再需要在每个库中都将vendor目录纳入其版本控制。go.sum文件确保在第一次安装之后不会处理任何包。此外,您的CI/CD在每次构建安装所有依赖项时都只需要很短的时间。

组件

从一个非常高的角度来看,系统中有三个主要的组件。

客户端

客户端必须是一个支持 module 的 go.编写该文档时,它是 Go v1.12+.

VCS

VCS 对 Athens 而言是一个外部源。Athens 扫描类似 github.com 等的多种 VCS,并获取源。

代理

我们部署在企业内部的代理主要是为了:

  • 托管私有模块
  • 排除对公有模块的访问
  • 存储公有模块

重点在于,这个代理并不打算成为上游代理的完整镜像。对于公有模块,它的角色是为了存储并提供访问控制。

安装 Athens

Go的生态系统一直是联合的,完全开放的。任何拥有GitHub或GitLab(或任何其他支持的VCS)帐户的人都可以轻松地通过git push(或类似命令)来提供库服务。 无需创建额外的帐户或设置凭据。

一个联合的生态系统

我们认为Athens应该保持社区的联合与开放,并且用户在构建应用程序和库时,无需更改工作流。 因此,为确保社区能够保持联合与开放,我们已为每个人提供了轻松安装Athens的方式,以便:

-任何人都可以运行自己的全功能镜像,无论是公共镜像还是私有镜像 -任何组织都可以运行自己的私有镜像,这样他们就可以像管理公共代码一样管理自己的私有代码

不变性

如您所知,go getgo mod download 命令将直接从GitHub等版本控制系统中获取软件包。 这个方式对于软件包开发人员和相关应用程序都非常好,但是与此同时,我们长期以来一直遇到一个基本问题。即,版本控制系统中的代码即使在提交之后也可以随时更改。例如,包开发人员可以运行"git push -f"并覆盖项目中依赖的提交或标记。在这些情况下,您经常会看到校验和验证错误,相关例子可参见这里

Athens通过将代码存储在其自己的不可变数据库中 来防止这些问题的发生。下面是当你运行go get时,发生的交互情况:

  1. go get向Athens请求一个模块
  2. Athens接受请求并开始搜寻该模块
  3. 首先,在后端存储中查找,如果找到了这个模块,Athens将立即返回(1)中发出请求的go get 客户端
  4. 如果找不到这个模块,则从版本控制系统中获取模块,保存在后端存储中,然后返回到(1)中的客户端

一旦将模块保存到存储中,Athens就不会更改任何内容,因此Athens具有以下两个重要属性:

  • 对某个模块的一个版本,Athens永远只调用 go mod download 一次 。换句话说,对于任何给定的模块和版本,Athens只会执行步骤(4)一次。
  • Athens处理存储的策略为仅追加,因此一旦模块被保存,它就永远不会改变,即使开发人员在GitHub上对其进行了更改

发布规则

我们遵循semver语义化版本号。 同时我们的Docker镜像打上了下列标签以表示镜像的稳定性:

  • latest = 最新的稳定版本
  • canary = mater分支最新构建出的版本

我们强烈建议您使用带标签的发行版镜像,例如 gomods/athens:v0.3.0, 而不是使用latest或canary标签的镜像。

拓展资源

为了确保易于安装,我们尝试提供尽可能多的方式来安装和运行Athens:

安装 Athens 的子部分

从源代码构建版本化的Athens二进制文件

您只需执行以下几个命令即可轻松实现构建Athens二进制文件:

Bash

git clone https://github.com/gomods/athens
cd athens
make build-ver VERSION="0.2.0"

PowerShell

git clone https://github.com/gomods/athens
cd athens
$env:GO111MODULE="on"
$env:GOPROXY="https://proxy.golang.org"
$version = "0.2.0"
$date = (Get-Date).ToUniversalTime()
go build -ldflags "-X github.com/gomods/athens/pkg/build.version=$version -X github.com/gomods/athens/pkg/build.buildDate=$date" -o athens ./cmd/proxy

这将生成一个名为athens的二进制文件. 你可以通过下列命令打印版本以及构建时间:

 ./athens -version

which should return something like:

Build Details:
        Version:        0.2.0
        Date:           2018-12-13-20:51:06-UTC

在Kubernetes上安装Athens

当您按照Walkthrough中的说明进行操作时, 最终会得到使用内存作为存储的Athens。 这仅适用于短时间试用Athens,因为您将很快耗尽内存,并且Athens在两次重启之间不会保留储存的模块(modules)。 为了使Athens运行在一个更接近生产级别的环境上, 您可能需要在 Kubernetes 集群上运行Athens. 为了帮助在Kubernetes上部署Athens,, 我们提供了一个 Helm chart . 本指南将指导您使用Helm将Athens安装在Kubernetes集群上。


前提条件

为了在Kubernetes集群上安装Athens,您必须满足一些前提条件.如果您已经完成以下步骤,请继续执行配置Helm. 本指南假设您已经创建了Kubernetes集群.

安装Kubernetes CLI

为了与Kubernetes集群进行交互,您需要 安装 kubectl

安装Helm CLI

Helm 是用于在Kubernetes上安装预先配置好的应用程序的工具。 可以通过运行以下命令来安装helm

MacOS

brew install kubernetes-helm

Windows

  1. 下载最新版本的 Helm release
  2. 解压tar文件。
  3. 拷贝 helm.exe 到系统 PATH 中的一个目录下.

Linux

curl https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get | bash

配置Helm

如果您的集群已配置为使用Helm,请继续部署Athens.

如果没有,请继续阅读。

RBAC 集群

如果您的集群启用了RBAC,则需要创建ServiceAccount,ClusterRole和ClusterRoleBinding以供Helm使用。 以下命令将创建它们并初始化Helm。

kubectl create -f https://raw.githubusercontent.com/Azure/helm-charts/master/docs/prerequisities/helm-rbac-config.yaml
helm init --service-account tiller

非RBAC 集群

如果您的集群没有启用rbac,则可以轻松初始化helm。

helm init

在部署Athens之前, 你需要等待Tiller的pod变成 Ready状态. 您可以通过查看 kube-system中的Pod来检查状态:

$ kubectl get pods -n kube-system -w
NAME                                    READY     STATUS    RESTARTS   AGE
tiller-deploy-5456568744-76c6s          1/1       Running   0          5s

部署Athens

使用Helm安装Athens的最快方法是从我们的公共Helm Chart库中进行部署。 首先,使用以下命令添加库

$ helm repo add gomods https://gomods.github.io/athens-charts
$ helm repo update

接下来,将含有默认值的chart安装到athens命名空间:

$ helm install gomods/athens-proxy -n athens --namespace athens

这将在athens命名空间中部署一个启用了disk本地存储的Athens实例。此外,还将创建一个ClusterIP服务。

高级配置

多副本

默认情况下,该chart将安装副本数量为1的athens。要更改此设置,请更改replicaCount值:

helm install gomods/athens-proxy -n athens --namespace athens --set replicaCount=3

资源

默认情况下,该chart将在没有特定资源请求或限制的情况下安装athens。 要更改此设置,请更改resources值:

helm install gomods/athens-proxy -n athens --namespace athens \
  --set resources.requests.cpu=100m \
  --set resources.requests.memory=64Mi \
  --set resources.limits.cpu=100m \
  --set resources.limits.memory=64Mi

有关更多信息,请参阅Kubernetes文档中的管理容器的计算资源

通过Github令牌(Token)授予athens访问私有存储库的权限(可选)

  1. https://github.com/settings/tokens 上创建一个令牌(Token)
  2. 通过 config.toml 文件 ( GithubToken 字段) 或 通过设置ATHENS_GITHUB_TOKEN 环境变量,将令牌提供给Athens代理.

存储提供程序(storage provider)

Helm chart目前支持使用两个不同的存储提供程序来运行Athens:diskmongo。 默认使用的是disk存储提供程序。

磁盘存储配置

当使用disk存储提供程序时,可以配置许多有关数据持久性的选项。默认情况下,雅典将使用emptyDir卷进行部署。这可能不足以满足生产用例,因此该chart还允许您通过PersistentVolumeClaim配置持久性。该chart目前允许您设置以下值:

persistence:
  enabled: false
  accessMode: ReadWriteOnce
  size: 4Gi
  storageClass:

将其添加到override values.yaml文件并运行:

helm install gomods/athens-proxy -n athens --namespace athens -f override-values.yaml

enabled用于打开chart的PVC功能,而其他值直接与PersistentVolumeClaim中定义的值相关。

Mongo DB 配置

要使用Mongo DB存储提供程序,您首先需要一个MongoDB实例。当部署了MongoDB后,就可以通过storage.mongo.url字段使用连接字符串配置Athens。 您还需将storage.type设置为“mongo”。

helm install gomods/athens-proxy -n athens --namespace athens --set storage.type=mongo --set storage.mongo.url=<some-mongodb-connection-string>

S3 配置

要在Athens中使用S3存储,请将storage.type设置为s3,并将storage.s3.regionstorage.s3.bucket分别设置为所使用的AWS区域和S3存储桶名称。 默认情况下,Athens将尝试使用AWS SDK从环境变量、共享凭证文件(shared credentials files)和EC2实例凭证组成的链中加载AWS凭证。 要手动指定AWS凭证,请设置storage.s3.access_key_idstorage.s3.secret_access_key,并将storage.s3.useDefaultConfiguration更改为false

helm install gomods/athens-proxy -n athens --namespace athens --set storage.type=s3 --set storage.s3.region=<your-aws-region> --set storage.s3.bucket=<your-bucket>

Minio 配置

若要在Athens中使用S3存储,请将storage.type设置为minio。您需要设置storage.minio.endpoint 作为minio安装的URL。这个URL也可以是kubernetes内部地址的(例如minio-service.default.svc)。您需要在minio安装过程中创建一个桶(bucket)或使用现有的一个桶。桶需要在storage.minio.bucket中引用。最后,Athens需要在storage.minio.accesskeystorage.minio.secretkey中设置您的minio的身份验证凭据。

helm install gomods/athens-proxy -n athens --namespace athens --set storage.type=minio --set storage.minio.endpoint=<your-minio-endpoint> --set storage.minio.bucket=<your-bucket> --set storage.minio.accessKey=<your-minio-access-key> --set storage.minio.secretKey=<your-minio-secret-key>

Kubernetes 服务

默认情况下,Kubernetes中为Athens创建了一个ClusterIP 服务。在Kubernetes集群内使用Athens的场景下,clusterip就足够用了。如果要在Kubernetes集群外提供Athens的服务,请考虑使用“nodeport”或“loadbalancer”。可以在安装chart时通过设置service.type值来更改此设置。例如,要使用nodeport服务部署Athens,可以使用以下命令:

helm install gomods/athens-proxy -n athens --namespace athens --set service.type=NodePort

Ingress 资源

该chart可以选择性为您的创建一个Kubernetes Ingress 资源。要启用此功能,请将ingress.enabled资源设置为true。

helm install gomods/athens-proxy -n athens --namespace athens --set ingress.enabled=true

values.yaml文件中提供了更多配置选项:

ingress:
  enabled: true
  annotations:
    certmanager.k8s.io/cluster-issuer: "letsencrypt-prod"
    kubernetes.io/tls-acme: "true"
    ingress.kubernetes.io/force-ssl-redirect: "true"
    kubernetes.io/ingress.class: nginx
  hosts:
    - athens.mydomain.com
  tls:
    - secretName: athens.mydomain.com
      hosts:
        - "athens.mydomain.com

上述的示例使用cert-managerLet’s Encrypt设置TLS证书的自动创建/检索。 并使用nginx-ingress controller 将Athens对外暴露于互联网中。

将其添加到override-values.yaml文件中并运行:

helm install gomods/athens-proxy -n athens --namespace athens -f override-values.yaml

上游的模块(module)库

您可以为上游模块库设置URL,然后当Athens在自己的存储中找不到某个模块(module)时,它将尝试从上游模块库中下载该模块。

对于可用的为上游模块库,一下是几个好的选择:

  • https://gocenter.io 使用JFrog的GoCenter
  • https://proxy.golang.org 使用Go Module 镜像
  • 指向任何其他Athens服务器的URL

以下示例显示了如何将GoCenter设置为上游模块库:

upstreamProxy:
  enabled: true
  url: "https://gocenter.io"

将其添加到 override-values.yaml 文件里并运行:

helm install gomods/athens-proxy -n athens --namespace athens -f override-values.yaml

.netrc文件支持

.netrc文件可以作为密钥共享,以允许访问私有模块。 使用以下命令从netrc文件创建密钥(文件的名称必须为netrc):

kubectl create secret generic netrcsecret --from-file=./netrc

为了指导athens获取并使用密钥,netrc.enabled标志必须设置为true:

helm install gomods/athens-proxy -n athens --namespace athens --set netrc.enabled=true

gitconfig支持

gitconfig可以作为私钥共享,以允许访问私有git库中的模块。 例如,您可以使用GitHub,Gitlab和其他git服务上的个人访问令牌(token),通过HTTPS配置对私有存储库的访问。

首先,准备你的gitconfig文件:

cat << EOF > /tmp/gitconfig
[url "https://user:token@git.example.com/"]
    insteadOf = ssh://git@git.example.com/
    insteadOf = https://git.example.com/
EOF

接下来,使用上面创建的文件创建密钥:

kubectl create secret generic athens-proxy-gitconfig --from-file=gitconfig=/tmp/gitconfig

为了使athens使用密钥,请设置适当的标志(或values.yaml中的参数):

helm install gomods/athens-proxy --name athens --namespace athens \
    --set gitconfig.enabled=true \
    --set gitconfig.secretName=athens-proxy-gitconfig \
    --set gitconfig.secretKey=gitconfig

共享团队实例

当您按照Walkthrough中的说明进行操作时,Athens最终使用的是本地存储空间。 这仅适用于短期试用Athens,因为您将很快耗尽内存,并且Athens在两次重启之间不会保留模块。 本指南将帮助您以一种更适合的方式运行Athens,以用于提供一个实例供开发团队共享的场景。

我们将使用Docker来运行Athens,因此首先请确保您已经安装Docker.

选择存储提供程序

Athens目前支持许多存储驱动程序。 对于本机使用,建议从使用本地磁盘作为存储提供程序开始使用。对于其他提供商,请参阅 the Storage Provider documentation.

使用本地磁盘作为存储安装Athens

为了使用本地磁盘存储来运行Athens,您接下来需要确定要将模块持久化的位置。 在下面的示例中,我们将在当前目录中创建一个名为athens-storage的新目录。现在您可以在启用磁盘存储的情况下运行Athen。 要启用本地磁盘存储,您需要在运行Docker容器时设置ATHENS_STORAGE_TYPEATHENS_DISK_STORAGE_ROOT环境变量。

为了简单起见,下面的示例使用:latest Docker标记,但是我们强烈建议您在环境启动并运行后切换到使用正式版本(例如:v0.3.0)。

Bash

export ATHENS_STORAGE=~/athens-storage
mkdir -p $ATHENS_STORAGE
docker run -d -v $ATHENS_STORAGE:/var/lib/athens \
   -e ATHENS_DISK_STORAGE_ROOT=/var/lib/athens \
   -e ATHENS_STORAGE_TYPE=disk \
   --name athens-proxy \
   --restart always \
   -p 3000:3000 \
   gomods/athens:latest

PowerShell

$env:ATHENS_STORAGE = "$(Join-Path $pwd athens-storage)"
md -Path $env:ATHENS_STORAGE
docker run -d -v "$($env:ATHENS_STORAGE):/var/lib/athens" `
   -e ATHENS_DISK_STORAGE_ROOT=/var/lib/athens `
   -e ATHENS_STORAGE_TYPE=disk `
   --name athens-proxy `
   --restart always `
   -p 3000:3000 `
   gomods/athens:latest

注意:如果您之前尚未使用Docker for Windows挂载此驱动器,则可能会提示您允许访问

Athens现在应该作为带有本地目录athens-storage的Docker容器运行。当Athens检索模块(module)时,它们将被存储在先前创建的目录中。首先,让我们确认雅典是否在运行:

$ docker ps
CONTAINER ID        IMAGE                               COMMAND           PORTS                    NAMES
f0429b81a4f9        gomods/athens:latest   "/bin/app"        0.0.0.0:3000->3000/tcp   athens-proxy

现在,我们可以从安装了Go v1.12+的任何机器上使用Athens。 要验证这一点,请尝试以下示例:

Bash

$ export GO111MODULE=on
$ export GOPROXY=http://127.0.0.1:3000
$ git clone https://github.com/athens-artifacts/walkthrough.git
$ cd walkthrough
$ go run .
go: downloading github.com/athens-artifacts/samplelib v1.0.0
The 🦁 says rawr!

PowerShell

$env:GO111MODULE = "on"
$env:GOPROXY = "http://127.0.0.1:3000"
git clone https://github.com/athens-artifacts/walkthrough.git
cd walkthrough
$ go run .
go: downloading github.com/athens-artifacts/samplelib v1.0.0
The 🦁 says rawr!

我们可以通过检查Docker日志来验证Athens是否处理了此请求:

$ docker logs -f athens-proxy
time="2018-08-21T17:28:53Z" level=warning msg="Unless you set SESSION_SECRET env variable, your session storage is not protected!"
time="2018-08-21T17:28:53Z" level=info msg="Starting application at 0.0.0.0:3000"
handler: GET /github.com/athens-artifacts/samplelib/@v/v1.0.0.info [200]
handler: GET /github.com/athens-artifacts/samplelib/@v/v1.0.0.mod [200]
handler: GET /github.com/athens-artifacts/samplelib/@v/v1.0.0.zip [200]

现在,如果查看athens_storage文件夹的内容,您将会看到与samplelib模块相关的新增文件。

Bash

$ ls -lr $ATHENS_STORAGE/github.com/athens-artifacts/samplelib/v1.0.0/
total 24
-rwxr-xr-x  1 jeremyrickard  wheel    50 Aug 21 10:52 v1.0.0.info
-rwxr-xr-x  1 jeremyrickard  wheel  2391 Aug 21 10:52 source.zip
-rwxr-xr-x  1 jeremyrickard  wheel    45 Aug 21 10:52 go.mod

PowerShell

$ dir $env:ATHENS_STORAGE\github.com\athens-artifacts\samplelib\v1.0.0\


    Directory: C:\athens-storage\github.com\athens-artifacts\samplelib\v1.0.0


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        8/21/2018   3:31 PM             45 go.mod
-a----        8/21/2018   3:31 PM           2391 source.zip
-a----        8/21/2018   3:31 PM             50 v1.0.0.info

重新启动Athens后,它将在该位置提供模块(module),而无需重新下载。 为了验证这一点,我们需要首先删除Athens容器。

docker rm -f athens-proxy

接下来,我们需要清除本地Go模块中的缓存。 这是必要的,以便您本地的Go命令行工具从Athens重新下载该模块。 以下命令将清除本地存储中的模块:

Bash

sudo rm -fr "$(go env GOPATH)/pkg/mod"

PowerShell

rm -recurse -force $(go env GOPATH)\pkg\mod

现在,我们重新运行Athens容器

Bash

docker run -d -v $ATHENS_STORAGE:/var/lib/athens \
   -e ATHENS_DISK_STORAGE_ROOT=/var/lib/athens \
   -e ATHENS_STORAGE_TYPE=disk \
   --name athens-proxy \
   --restart always \
   -p 3000:3000 \
   gomods/athens:latest

PowerShell

docker run -d -v "$($env:ATHENS_STORAGE):/var/lib/athens" `
   -e ATHENS_DISK_STORAGE_ROOT=/var/lib/athens `
   -e ATHENS_STORAGE_TYPE=disk `
   --name athens-proxy `
   --restart always `
   -p 3000:3000 `
   gomods/athens:latest

当我们重新运行我们的Go示例时,Go cli将再次从Athens下载模块。然而,Athens不需要重新检索模块。它将从本地磁盘中获取。

Bash

$ ls -lr $ATHENS_STORAGE/github.com/athens-artifacts/samplelib/v1.0.0/
total 24
-rwxr-xr-x  1 jeremyrickard  wheel    50 Aug 21 10:52 v1.0.0.info
-rwxr-xr-x  1 jeremyrickard  wheel  2391 Aug 21 10:52 source.zip
-rwxr-xr-x  1 jeremyrickard  wheel    45 Aug 21 10:52 go.mod

PowerShell

$ dir $env:ATHENS_STORAGE\github.com\athens-artifacts\samplelib\v1.0.0\


    Directory: C:\athens-storage\github.com\athens-artifacts\samplelib\v1.0.0


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        8/21/2018   3:31 PM             45 go.mod
-a----        8/21/2018   3:31 PM           2391 source.zip
-a----        8/21/2018   3:31 PM             50 v1.0.0.info

请注意文件的时间戳并没有更改

下一步:

在Azure Container Instances上安装Athens

当您按照Walkthrough中的说明进行操作时,Athens最终使用的是本地存储空间。 这仅适用于短期试用Athens,因为您将很快耗尽内存,并且Athens在两次重启之间不会保留模块。 本指南将帮助您以一种更适合的方式运行Athens,以用于提供一个实例供开发团队共享的场景。

在本文中,我们将展示如何在 Azure Container Instances (ACI) 上运行Athens.

选择存储提供商(Provider)

Athens目前支持许多存储驱动。 为了在ACI上能快捷的使用,我们建议使用本地磁盘作为存储。如果希望更持久的存储数据,我们建议使用MongoDB或其他持久化存储架构。 对于其他提供商,请参阅 storage provider documentation.

必需的环境变量

在执行以下任何命令之前,请确保在系统上设置了下列环境变量:

  • AZURE_ATHENS_RESOURCE_GROUP - 指定用于安装容器的 Azure Resource Group 。在安装Athens之前,你需要设置该环境变量。 -有关如何创建资源组(resource group)的详细信息,详见此处
  • AZURE_ATHENS_CONTAINER_NAME - 容器的名称。 应为字母和数字,可以包含“-”和“uu”字符
  • LOCATION - 指定用于安装容器的 Azure region 。有关详细列表,请参见上一链接, 同时这里有一个有用的备忘表,你可以立即使用,而不必阅读任何文档:
    • 北美: eastus2
    • 欧洲: westeurope
    • 亚洲: southeastasia
  • AZURE_ATHENS_DNS_NAME - 要分配给容器的DNS名称。它必须在您设置的区域(region)内是全局唯一的 (LOCATION)

使用本地磁盘驱动进行安装

az container create \
-g "${AZURE_ATHENS_RESOURCE_GROUP}" \
-n "${AZURE_ATHENS_CONTAINER_NAME}-${LOCATION}" \
--image gomods/athens:v0.3.0 \
-e "ATHENS_STORAGE_TYPE=disk" "ATHENS_DISK_STORAGE_ROOT=/var/lib/athens" \
--ip-address=Public \
--dns-name="${AZURE_ATHENS_DNS_NAME}" \
--ports="3000" \
--location=${LOCATION}

创建ACI容器后,您将看到一个JSON Blob对象,其中包含该容器的公有IP地址. 您还将看到正在运行的容器的 fully qualified domain name (FQDN) (以 AZURE_ATHENS_DNS_NAME为前缀)。

使用MongoDB驱动进行安装

首先,请确保您设置了以下环境变量:

  • AZURE_ATHENS_MONGO_URL - MongoDB 连接字符串。例如: mongodb://username:password@mongo.server.com/?ssl=true

然后运行下列创建的命令:

az container create \
-g "${AZURE_ATHENS_RESOURCE_GROUP}" \
-n "${AZURE_ATHENS_CONTAINER_NAME}-${LOCATION}" \
--image gomods/athens:v0.3.0 \
-e "ATHENS_STORAGE_TYPE=mongo" "ATHENS_MONGO_STORAGE_URL=${AZURE_ATHENS_MONGO_URL}" \
--ip-address=Public \
--dns-name="${AZURE_ATHENS_DNS_NAME}" \
--ports="3000" \
--location=${LOCATION}

创建ACI容器后,您将看到一个JSON Blob对象,其中包含该容器的公有IP地址. 您还将看到正在运行的容器的 fully qualified domain name (FQDN) (以 AZURE_ATHENS_DNS_NAME为前缀)。

使用.netrc文件管理私人仓库

通过.netrc文件认证访问私有仓库

  1. 创建一个.netrc文件,如下所示:

    machine <ip or fqdn>

    login <username>

    password <user password>

  2. 通过环境变量通知Athens该文件的位置:

    ATHENS_NETRC_PATH=<location/to/.netrc>

  3. Athens将文件复制到home目录,并覆盖home目录中的任何.netrc文件。或者,如果Athens服务器的主机在home目录中已经存在一个.netrc文件,则身份验证可开箱即用。

通过.hgrc认证访问Mercurial私有存储库

  1. 创建带有身份验证数据的.hgrc文件

  2. 通过环境变量通知Athens该文件的位置

    ATHENS_HGRC_PATH=<location/to/.hgrc>

  3. Athens将会把文件复制到home目录,并覆盖home目录中的任何.hgrc文件。或者,如果Athens服务器的主机在home目录中已经存在一个.hgrc文件,则身份验证可开箱即用。

Fork me on GitHub