Build-packs 不使用Dockerfile也能构建镜像

已于 2022-04-11 15:18:55 修改
阅读量1k 收藏
点赞数
文章标签： linux docker
于 2022-04-11 14:24:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47919821/article/details/124098227
版权

1.准备我们所需要的环境(docker 和pack 第二条命令可直接安装成功)

[root@yaqu002 ~]# docker -v
Docker version 20.10.14, build a224086
[root@yaqu002 ~]# (curl -sSL "https://github.com/buildpacks/pack/releases/download/v0.24.1/pack-v0.24.1-linux.tgz" | sudo tar -C /usr/local/bin/ --no-same-owner -xzv pack)

设置本地环境
首先，我们将创建一个示例 Ruby 应用程序，您可以在开发 buildpack 时使用它：

mkdir ruby-sample-app
在当前目录中创建一个名为的文件，其ruby-sample-app/app.rb内容如下：

require 'sinatra'

set :bind, '0.0.0.0'
set :port, 8080

get '/' do
  'Hello World!'
end
然后，创建一个名为的文件ruby-sample-app/Gemfile，其内容如下：

source "https://rubygems.org"

git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }

gem "sinatra"
最后，通过执行以下命令确保您的本地 Docker 守护程序正在运行：

docker version
如果您看到类似于以下的输出，那么您就可以开始了！否则，启动 Docker 并再次检查。

Client: Docker Engine - Community
 Version:           20.10.9
 API version:       1.41
 Go version:        go1.16.8
 Git commit:        c2ea9bc
 Built:             Mon Oct  4 16:08:29 2021
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.9
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.16.8
  Git commit:       79ea9d3
  Built:            Mon Oct  4 16:06:34 2021
  OS/Arch:          linux/amd64
  Experimental:     false
云原生 Buildpack 的构建块
现在我们将设置 buildpack 脚手架。

让我们创建 buildpack 所在的目录：

使用 Pack CLI
该buildpack new <id>命令将创建一个以 buildpack ID 命名的目录。

例子：

pack buildpack new examples/ruby \
    --api 0.7 \
    --path ruby-buildpack \
    --version 0.0.1 \
    --stacks io.buildpacks.samples.stacks.bionic
此命令将创建ruby-buildpack包含buildpack.toml, bin/build, bin/detect文件的目录。

附加参数
-a, --api生成的 buildpack 的 Buildpack API 兼容性
-h, --help“新”的帮助
--path文件系统上生成工件的位置。
--stacks此 buildpack 将兼容的堆栈。按顺序对每个堆栈重复，或按逗号分隔列表提供一次
-V, --versionbuildpack.toml 中的 buildpack 版本
buildpack.toml
您将ruby-buildpack/buildpack.toml在您的 buildpack 目录中描述我们的 buildpack。

# Buildpack API version
api = "0.7"

# Buildpack ID and metadata
[buildpack]
  id = "examples/ruby"
  version = "0.0.1"

# Stacks that the buildpack will work with
[[stacks]]
  id = "io.buildpacks.samples.stacks.bionic"
您会注意到文件中的两个特定字段：buildpack.id和stack.id. buildpack ID 是您在创建 buildpack 组、构建器等时引用 buildpack 的方式。堆栈 ID 是运行 buildpack 的根文件系统。此示例可以在两个不同堆栈之一上运行，均基于 Ubuntu Bionic。

detect和build 
接下来，我们将介绍detect和build脚本。这些文件是bin在你的 buildpack 目录中创建的。

现在更新您的ruby-buildpack/bin/detect文件并复制以下内容：

#!/usr/bin/env bash
set -eo pipefail

exit 1
还要更新您的ruby-buildpack/bin/build文件并复制以下内容：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"
exit 1
这两个文件是可执行文件detect和build脚本。您现在可以使用此 buildpack。

使用你的 buildpackpack 
为了测试您的 buildpack，您需要使用packCLI 针对您的示例 Ruby 应用程序运行 buildpack。

通过运行以下命令设置您的默认构建器：

pack config default-builder cnbs/sample-builder:bionic
告诉 pack 信任我们的默认构建器：

pack config trusted-builders add cnbs/sample-builder:bionic
然后运行以下pack命令：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
该pack build命令将您的 Ruby 示例应用程序作为--path参数，并将您的 buildpack 作为--buildpack参数。

运行该命令后，您应该会看到它未能检测到，因为detect当前编写的脚本只是为了出错。

===> DETECTING
err:  examples/ruby@0.0.1 (1)
ERROR: No buildpack groups passed detection.
ERROR: failed to detect: buildpack(s) failed with err
检测您的应用程序
接下来，您将要实际检测您正在构​​建的应用程序是 Ruby 应用程序。为此，您需要检查Gemfile.

exit 1用detect以下检查替换脚本：

if [[ ! -f Gemfile ]]; then
   exit 100
fi
您的ruby-buildpack/bin/detect脚本应如下所示：

#!/usr/bin/env bash
set -eo pipefail

if [[ ! -f Gemfile ]]; then
   exit 100
fi
接下来，使用更新的 buildpack 重建您的应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
您应该看到以下输出：

===> ANALYZING
Previous image with name "test-ruby-app" not found
===> DETECTING
examples/ruby 0.0.1
===> RESTORING
===> BUILDING
---> Ruby Buildpack
ERROR: failed to build: exit status 1
ERROR: failed to build: executing lifecycle
请注意，detect现在通过了，因为Gemfile在 Ruby 应用程序中有一个有效的ruby-sample-app，但现在build失败了，因为它当前被写入错误输出。

您还会注意到ANALYZING现在出现在构建输出中。此步骤是 buildpack 生命周期的一部分，用于查看是否有任何先前的镜像构建具有 buildpack 可以重用的层。稍后我们将更详细地讨论这个主题。
构建您的应用程序
现在我们将更改您创建的构建步骤以安装应用程序依赖项。这将需要更新build脚本，以便它执行以下步骤：

为 Ruby 运行时创建一个层
下载 Ruby 运行时并将其安装到层
安装 Bundler（Ruby 依赖管理器）
使用 Bundler 安装依赖项
通过这样做，您将学习如何使用 buildpack 创建任意层，以及如何读取应用程序的内容以执行下载依赖项等操作。

让我们从更改 开始，ruby-buildpack/bin/build以便它为 Ruby 创建一个层。

创建图层
Buildpack 层由 Buildpack 执行环境提供给我们的 buildpack的层目录内的目录表示。要创建一个代表 Ruby 运行时的新层目录，请将build脚本更改为如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

layersdir=$1

rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"
该rubylayer目录是作为构建脚本的第一个位置参数提供的目录的子目录（层目录），这是我们将存储 Ruby 运行时的地方。

接下来，我们将下载 Ruby 运行时并将其安装到层目录中。将以下代码添加到build脚本末尾：

echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"
此代码使用该wget工具从给定的 URL 下载 Ruby 二进制文件，并将其解压缩到rubylayer目录中。

创建层的最后一步是编写一个包含层元数据的 TOML 文件。TOML 文件的名称必须与图层的名称匹配（在本例中为ruby.toml）。如果没有这个文件，Buildpack 生命周期将忽略层目录。launch对于 Ruby 层，我们需要通过将密钥设置为 来确保它在启动映像中可用true。将以下代码添加到构建脚本中：

echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"
安装依赖
接下来，我们将使用您安装的 Ruby 运行时来下载应用程序的依赖项。首先，我们需要通过将 Ruby 可执行文件放在 Path 中来使我们的脚本可以使用它。将以下代码添加到build脚本末尾：

export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"
现在我们可以安装 Bundler，一个 Ruby 的依赖管理器，然后运行bundle install命令。将以下代码附加到脚本中：

echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

echo "---> Installing gems"
bundle install
现在 Buildpack 已准备好进行测试。

运行构建
您的完整ruby-buildpack/bin/build脚本应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# 7. INSTALL GEMS
echo "---> Installing gems"
bundle install
再次构建您的应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
您将看到以下输出：

===> DETECTING
...
===> ANALYZING
...
===> RESTORING
===> BUILDING
---> Ruby Buildpack
---> Downloading and extracting Ruby
---> Installing bundler
...
---> Installing gems
...
===> EXPORTING
...
Successfully built image 'test-ruby-app'
在您的 Docker 守护程序中创建了一个名为的新映像test-ruby-app，其中包含 Ruby 运行时的层。但是，您的应用映像还不能运行。我们将在下一节中使应用程序映像可运行。
使您的应用程序可运行
要使您的应用程序可运行，必须设置默认启动命令。您需要将以下内容添加到build脚本的末尾：

# ...

# Set default start command
cat > "$layersdir/launch.toml" << EOL
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true
EOL

# ...
您的完整ruby-buildpack/bin/build脚本现在应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# 7. INSTALL GEMS
echo "---> Installing gems"
bundle install

# ========== ADDED ===========
# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true
EOL
然后使用更新的 buildpack 重建您的应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
然后，您应该能够运行新的 Ruby 应用程序：

docker run --rm -p 8080:8080 test-ruby-app
并查看服务器日志输出：

[2019-04-02 18:04:48] INFO  WEBrick 1.4.2
[2019-04-02 18:04:48] INFO  ruby 2.5.1 (2018-03-29) [x86_64-linux]
== Sinatra (v2.0.5) has taken the stage on 8080 for development with backup from WEBrick
[2019-04-02 18:04:48] INFO  WEBrick::HTTPServer#start: pid=1 port=8080
通过在您最喜欢的浏览器中导航到localhost:8080来测试它！

我们可以将多种进程类型添加到单个应用程序中。我们将在下一节中这样做。
指定多个进程类型
buildpacks 的好处之一是它们是多进程的——一个映像可以为每个操作模式有多个入口点。让我们看看这是如何工作的。我们将扩展我们的应用程序以拥有一个工作进程。

让我们创建一个ruby-sample-app/worker.rb包含以下内容的工作文件：

for i in 0..5
    puts "Running a worker task..."
end
构建我们的应用程序后，我们可以使用web进程（当前默认）或我们的新工作进程运行生成的图像。

为了能够运行工作进程，我们需要让我们的 buildpack 为工作进程定义一个“进程类型”。将定义流程的部分修改为：

# ...

cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL

# ...
您的完整ruby-buildpack/bin/build脚本现在应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# 7. INSTALL GEMS
echo "---> Installing gems"
bundle install

# ========== MODIFIED ===========
# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL
现在，如果您使用更新的 buildpack 重建您的应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
然后，您应该能够运行新的 Ruby 工作进程：

docker run --rm --entrypoint worker test-ruby-app
并查看工作日志输出：

Running a worker task...
Running a worker task...
Running a worker task...
Running a worker task...
Running a worker task...
Running a worker task...
接下来，我们将看看如何通过利用缓存来改进我们的 buildpack。


通过缓存提高性能
我们可以通过缓存构建之间的依赖关系来提高性能，只在必要时重新下载。首先，让我们创建一个可缓存bundler层。

创建bundler图层
为此，请替换build脚本中的以下行：

echo "---> Installing gems"
bundle install
具有以下内容：

echo "---> Installing gems"
bundlerlayer="$layersdir/bundler"
mkdir -p "$bundlerlayer"
echo -e '[types]\ncache = true\nlaunch = true' > "$layersdir/bundler.toml"
bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"
您的完整ruby-buildpack/bin/build脚本现在应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# ======= MODIFIED =======
# 7. INSTALL GEMS
echo "---> Installing gems"
bundlerlayer="$layersdir/bundler"
mkdir -p "$bundlerlayer"
echo -e '[types]\ncache = true\nlaunch = true' > "$layersdir/bundler.toml"
bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"

# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL
现在当我们运行时：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
在此阶段，您将看到类似于以下内容EXPORTING：

Adding layer 'examples/ruby:bundler'
缓存依赖项
现在，让我们实现缓存逻辑。我们首先需要创建一个ruby-sample-app/Gemfile.lock包含以下内容的文件：

通常你会在bundle install本地运行来生成这个文件，但为了简单起见，我们将ruby-sample-app/Gemfile.lock手动创建。

GEM
  remote: https://rubygems.org/
  specs:
    mustermann (1.0.3)
    rack (2.0.7)
    rack-protection (2.0.7)
      rack
    sinatra (2.0.7)
      mustermann (~> 1.0)
      rack (~> 2.0)
      rack-protection (= 2.0.7)
      tilt (~> 2.0)
    tilt (2.0.9)

PLATFORMS
  ruby

DEPENDENCIES
  sinatra

BUNDLED WITH
   2.0.2
替换上一步中的 gem 安装逻辑：

# ...

echo "---> Installing gems"
bundlerlayer="$layersdir/bundler"
mkdir -p "$bundlerlayer"
echo -e '[types]\ncache = true\nlaunch = true' > "$layersdir/bundler.toml"
bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"


# ...
使用下面的新逻辑检查是否有任何宝石已更改。这只是为先前创建一个校验Gemfile.lock和并将其与当前的校验和进行比较Gemfile.lock。如果它们相同，则重复使用这些宝石。如果不是，则安装新的 gem。

我们现在将额外的元数据写入我们bundler.toml的表单cache = true和launch = true. 这指导生命周期缓存我们的 gem 并在启动我们的应用程序时提供它们。使用cache = true生命周期可以保留现有的 gem，以便构建时间很快，即使是微小的Gemfile.lock变化。

请注意，有时您可能希望从以前的构建中清除缓存层，在这种情况下，您应该始终确保在继续构建之前删除层的内容。在下面的情况下，这可以在命令rm -rf "$bundlerlayer"/*之后使用简单的来完成。mkdir -p "$bundlerlayer"

# Compares previous Gemfile.lock checksum to the current Gemfile.lock
bundlerlayer="$layersdir/bundler"
local_bundler_checksum=$((sha256sum Gemfile.lock || echo 'DOES_NOT_EXIST') | cut -d ' ' -f 1)
remote_bundler_checksum=$(cat "$layersdir/bundler.toml" | yj -t | jq -r .metadata.checksum 2>/dev/null || echo 'DOES_NOT_EXIST')

# Always set the types table so that we re-use the appropriate layers
echo -e '[types]\ncache = true\nlaunch = true' >> "$layersdir/bundler.toml"

if [[ -f Gemfile.lock && $local_bundler_checksum == $remote_bundler_checksum ]] ; then
    # Determine if no gem dependencies have changed, so it can reuse existing gems without running bundle install
    echo "---> Reusing gems"
    bundle config --local path "$bundlerlayer" >/dev/null
    bundle config --local bin "$bundlerlayer/bin" >/dev/null
else
    # Determine if there has been a gem dependency change and install new gems to the bundler layer; re-using existing and un-changed gems
    echo "---> Installing gems"
    mkdir -p "$bundlerlayer"
    cat > "$layersdir/bundler.toml" << EOL
[metadata]
checksum = "$local_bundler_checksum"
EOL
    bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"

fi
您的完整ruby-buildpack/bin/build脚本现在将如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
echo "---> Downloading and extracting Ruby"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-2.5.1.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# ======= MODIFIED =======
# 7. INSTALL GEMS
# Compares previous Gemfile.lock checksum to the current Gemfile.lock
bundlerlayer="$layersdir/bundler"
local_bundler_checksum=$((sha256sum Gemfile.lock || echo 'DOES_NOT_EXIST') | cut -d ' ' -f 1)
remote_bundler_checksum=$(cat "$layersdir/bundler.toml" | yj -t | jq -r .metadata.checksum 2>/dev/null || echo 'DOES_NOT_EXIST')
# Always set the types table so that we re-use the appropriate layers
echo -e '[types]\ncache = true\nlaunch = true' >> "$layersdir/bundler.toml"

if [[ -f Gemfile.lock && $local_bundler_checksum == $remote_bundler_checksum ]] ; then
    # Determine if no gem dependencies have changed, so it can reuse existing gems without running bundle install
    echo "---> Reusing gems"
    bundle config --local path "$bundlerlayer" >/dev/null
    bundle config --local bin "$bundlerlayer/bin" >/dev/null
else
    # Determine if there has been a gem dependency change and install new gems to the bundler layer; re-using existing and un-changed gems
    echo "---> Installing gems"
    mkdir -p "$bundlerlayer"
    cat >> "$layersdir/bundler.toml" << EOL
[metadata]
checksum = "$local_bundler_checksum"
EOL
    bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"

fi

# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL
现在，当您构建应用程序时：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
它将下载宝石：

===> BUILDING
---> Ruby Buildpack
---> Downloading and extracting Ruby
---> Installing bundler
...
---> Installing gems
如果您再次构建应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
您将在此阶段看到新的缓存逻辑在工作BUILDING：

===> BUILDING
---> Ruby Buildpack
---> Downloading and extracting Ruby
---> Installing bundler
...
---> Reusing gems
接下来，让我们看看 buildpack 用户如何能够为 buildpack 提供配置。
使您的 buildpack 可配置
很可能并非所有 Ruby 应用程序都希望使用相同版本的 Ruby。让我们使 Ruby 版本可配置。

选择 Ruby 版本
我们将允许 buildpack 用户通过其应用程序中的文件定义所需的 Ruby 版本.ruby-version。我们将首先更新detect脚本以检查此文件。然后，我们将记录我们可以使用的依赖项provide（Ruby），以及应用程序将require在Build Plan文档中记录的特定依赖项，生命周期用于确定 buildpack 是否会提供应用程序所需的一切。

更新ruby-buildpack/bin/detect为如下所示：

#!/usr/bin/env bash
set -eo pipefail

if [[ ! -f Gemfile ]]; then
   exit 100
fi

# ======= ADDED =======
plan=$2
version=2.5.1

if [[ -f .ruby-version ]]; then
    version=$(cat .ruby-version | tr -d '[:space:]')
fi

echo "provides = [{ name = \"ruby\" }]" > "$plan"
echo "requires = [{ name = \"ruby\", metadata = { version = \"$version\" } }]" >> "$plan"
# ======= /ADDED =======
然后您需要更新您的build脚本以在构建计划中查找记录的 Ruby 版本：

您的ruby-buildpack/bin/build脚本应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# ======= MODIFIED =======
# 1. GET ARGS
layersdir=$1
plan=$3

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# ======= MODIFIED =======
# 3. DOWNLOAD RUBY
ruby_version=$(cat "$plan" | yj -t | jq -r '.entries[] | select(.name == "ruby") | .metadata.version')
echo "---> Downloading and extracting Ruby $ruby_version"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-$ruby_version.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# 7. INSTALL GEMS
# Compares previous Gemfile.lock checksum to the current Gemfile.lock
bundlerlayer="$layersdir/bundler"
local_bundler_checksum=$((sha256sum Gemfile.lock || echo 'DOES_NOT_EXIST') | cut -d ' ' -f 1)
remote_bundler_checksum=$(cat "$layersdir/bundler.toml" | yj -t | jq -r .metadata.checksum 2>/dev/null || echo 'DOES_NOT_EXIST')
# Always set the types table so that we re-use the appropriate layers
echo -e '[types]\ncache = true\nlaunch = true' >> "$layersdir/bundler.toml"

if [[ -f Gemfile.lock && $local_bundler_checksum == $remote_bundler_checksum ]] ; then
    # Determine if no gem dependencies have changed, so it can reuse existing gems without running bundle install
    echo "---> Reusing gems"
    bundle config --local path "$bundlerlayer" >/dev/null
    bundle config --local bin "$bundlerlayer/bin" >/dev/null
else
    # Determine if there has been a gem dependency change and install new gems to the bundler layer; re-using existing and un-changed gems
    echo "---> Installing gems"
    mkdir -p "$bundlerlayer"
    cat >> "$layersdir/bundler.toml" << EOL
[metadata]
checksum = "$local_bundler_checksum"
EOL
    bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"

fi

# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL
最后，创建一个ruby-sample-app/.ruby-version包含以下内容的文件：

2.5.0
现在当你运行时：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
您会注意到.ruby-version下载了应用程序文件中指定的 Ruby 版本。

===> BUILDING
---> Ruby Buildpack
---> Downloading and extracting Ruby 2.5.0
接下来，让我们看看 buildpacks 如何存储有关输出应用程序映像中提供的依赖项的信息以进行自省。


添加物料清单
buildpacks 的好处之一是它们还可以使用构建过程中的元数据填充应用程序映像，从而允许您审核应用程序映像以获取以下信息：

可用的进程类型以及与之关联的命令
应用映像所基于的运行映像
buildpacks 用于创建应用程序映像
和更多…！
pack您可以通过其inspect-image命令找到其中一些信息。物料清单信息将使用 提供pack sbom download。

pack inspect-image test-ruby-app
您应该看到以下内容：

Run Images:
  cnbs/sample-stack-run:bionic

Buildpacks:
  ID                   VERSION        HOMEPAGE
  examples/ruby        0.0.1          -

Processes:
  TYPE                 SHELL        COMMAND                        ARGS
  web (default)        bash         bundle exec ruby app.rb        
  worker               bash         bundle exec ruby worker.rb
除了上述标准元数据之外，构建包还可以填充有关它们以Bill-of-Materials. 让我们看看我们如何使用它来填充有关ruby在输出应用程序图像中安装的版本的信息。

要将ruby版本添加到 的输出中pack download sbom，我们必须提供包含此信息的软件Bill-of-Materials( )。SBOM报告 SBOM 数据有三种“标准”方式。您需要选择在脚本末尾使用CycloneDX、SPDX或Syft更新ruby.sbom.<ext>（<ext>适合您的 SBOM 标准的扩展名，其中之一cdx.json，spdx.json或syft.json）build。关于选择哪种 SBOM 格式的讨论超出了本教程的范围，但我们会注意到，您选择使用的 SBOM 格式很可能是任何 SBOM 扫描仪的输出格式（例如：syft cli) 您可能会选择使用。在本例中，我们将使用 CycloneDX json 格式。

首先，注释buildpack.toml以指定它发出 CycloneDX：

# Buildpack API version
api = "0.7"

# Buildpack ID and metadata
[buildpack]
  id = "examples/ruby"
  version = "0.0.1"
  sbom-formats = [ "application/vnd.cyclonedx+json" ]

# Stacks that the buildpack will work with
[[stacks]]
  id = "io.buildpacks.samples.stacks.bionic"
然后，在我们的 buildpack 实现中，我们将生成必要的 SBOM 元数据：

# ...

# Append a Bill-of-Materials containing metadata about the provided ruby version
cat >> "$layersdir/ruby.sbom.cdx.json" << EOL
{
  "bomFormat": "CycloneDX",
  "specVersion": "1.4",
  "version": 1,
  "components": [
    {
      "type": "library",
      "name": "ruby",
      "version": "$ruby_version"
    }
  ]
}
EOL
我们还可以为列出的每个依赖项添加一个 SBOM 条目Gemfile.lock。这里我们使用在数组中jq添加一条新记录：componentsbundler.sbom.cdx.json

crubybom="${layersdir}/ruby.sbom.cdx.json"
cat >> ${rubybom} << EOL
{
  "bomFormat": "CycloneDX",
  "specVersion": "1.4",
  "version": 1,
  "components": [
    {
      "type": "library",
      "name": "ruby",
      "version": "$ruby_version"
    }
  ]
}
EOL
if [[ -f Gemfile.lock ]] ; then
  for gem in $(gem dep -q | grep ^Gem | sed 's/^Gem //')
  do
    version=${gem##*-}
    name=${gem%-${version}}
    DEP=$(jq --arg name "${name}" --arg version "${version}" \
      '.components[.components| length] |= . + {"type": "library", "name": $name, "version": $version}' \
      "${rubybom}")
    echo ${DEP} > "${rubybom}"
  done
fi
您的ruby-buildpack/bin/build脚本应如下所示：

#!/usr/bin/env bash
set -eo pipefail

echo "---> Ruby Buildpack"

# 1. GET ARGS
layersdir=$1
plan=$3

# 2. CREATE THE LAYER DIRECTORY
rubylayer="$layersdir"/ruby
mkdir -p "$rubylayer"

# 3. DOWNLOAD RUBY
ruby_version=$(cat "$plan" | yj -t | jq -r '.entries[] | select(.name == "ruby") | .metadata.version')
echo "---> Downloading and extracting Ruby $ruby_version"
ruby_url=https://s3-external-1.amazonaws.com/heroku-buildpack-ruby/heroku-18/ruby-$ruby_version.tgz
wget -q -O - "$ruby_url" | tar -xzf - -C "$rubylayer"

# 4. MAKE RUBY AVAILABLE DURING LAUNCH
echo -e '[types]\nlaunch = true' > "$layersdir/ruby.toml"

# 5. MAKE RUBY AVAILABLE TO THIS SCRIPT
export PATH="$rubylayer"/bin:$PATH
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}"$rubylayer/lib"

# 6. INSTALL BUNDLER
echo "---> Installing bundler"
gem install bundler --no-ri --no-rdoc

# 7. INSTALL GEMS
# Compares previous Gemfile.lock checksum to the current Gemfile.lock
bundlerlayer="$layersdir/bundler"
local_bundler_checksum=$((sha256sum Gemfile.lock || echo 'DOES_NOT_EXIST') | cut -d ' ' -f 1)
remote_bundler_checksum=$(cat "$layersdir/bundler.toml" | yj -t | jq -r .metadata.checksum 2>/dev/null || echo 'DOES_NOT_EXIST')
# Always set the types table so that we re-use the appropriate layers
echo -e '[types]\ncache = true\nlaunch = true' >> "$layersdir/bundler.toml"

if [[ -f Gemfile.lock && $local_bundler_checksum == $remote_bundler_checksum ]] ; then
    # Determine if no gem dependencies have changed, so it can reuse existing gems without running bundle install
    echo "---> Reusing gems"
    bundle config --local path "$bundlerlayer" >/dev/null
    bundle config --local bin "$bundlerlayer/bin" >/dev/null
else
    # Determine if there has been a gem dependency change and install new gems to the bundler layer; re-using existing and un-changed gems
    echo "---> Installing gems"
    mkdir -p "$bundlerlayer"
    cat >> "$layersdir/bundler.toml" << EOL
[metadata]
checksum = "$local_bundler_checksum"
EOL
    bundle config set --local path "$bundlerlayer" && bundle install && bundle binstubs --all --path "$bundlerlayer/bin"

fi

# 8. SET DEFAULT START COMMAND
cat > "$layersdir/launch.toml" << EOL
# our web process
[[processes]]
type = "web"
command = "bundle exec ruby app.rb"
default = true

# our worker process
[[processes]]
type = "worker"
command = "bundle exec ruby worker.rb"
EOL

# ========== ADDED ===========
# 9. ADD A SBOM
rubybom="${layersdir}/ruby.sbom.cdx.json"
cat >> ${rubybom} << EOL
{
  "bomFormat": "CycloneDX",
  "specVersion": "1.4",
  "version": 1,
  "components": [
    {
      "type": "library",
      "name": "ruby",
      "version": "$ruby_version"
    }
  ]
}
EOL
if [[ -f Gemfile.lock ]] ; then
  for gem in $(gem dep -q | grep ^Gem | sed 's/^Gem //')
  do
    version=${gem##*-}
    name=${gem%-${version}}
    DEP=$(jq --arg name "${name}" --arg version "${version}" \
      '.components[.components| length] |= . + {"type": "library", "name": $name, "version": $version}' \
      "${rubybom}")
    echo ${DEP} > "${rubybom}"
  done
fi
然后使用更新的 buildpack 重建您的应用程序：

pack build test-ruby-app --path ./ruby-sample-app --buildpack ./ruby-buildpack
查看您的物料清单需要download从您的本地图像中提取（或提取）物料清单。此命令可能需要一些时间才能返回。

pack sbom download test-ruby-app
SBOM 信息现在已下载到本地文件系统：

cat layers/sbom/launch/examples_ruby/ruby/sbom.cdx.json | jq -M
您应该会发现包含的ruby版本2.5.0与预期的一样。

{
  "bomFormat": "CycloneDX",
  "specVersion": "1.4",
  "version": 1,
  "components": [
    {
      "type": "library",
      "name": "ruby",
      "version": "2.5.0"
    },
...
  ]
}
恭喜！您已经创建了第一个可配置的 Cloud Native Buildpack，它使用检测、图像层和缓存来创建可自省且可运行的 OCI 图像。

尼古拉斯-邓
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
buildpacks：旨在在Google Cloud的容器平台上运行的构建器和buildpacks
02-04
Google Cloud构建包 该存储库包含一组旨在在Google Cloud的容器平台上运行的构建器和buildpack： ， ， 和 。 它们还用作和的构建系统。 它们与 100％兼容。 快速开始 克隆： git clone https://github.com/GoogleCloudPlatform/buildpack-samples.git cd buildpack-samples 选择一个样本并进行构建，例如，使用sample-go ： cd sample-go pack build --builder gcr.io/buildpacks/builder:v1 sample
Buildpacks高效构建Spring Boot应用Docker镜像
码农小胖哥
05-25 1314
1. 前言Spring Boot 2.3.0.RELEASE 正式发布了几天了，其中有个新的特性：可以将 Spring Boot 应用代码直接打包为 Docker 镜像。这是什么科技？我...
Cloud Native Buildpacks 学习笔记（一）
billfu007的博客
10-25 997
基本的核心概念 buildpacks是什么? buildpacks允许你将你的源代码变成一个安全的，有效率的，生产就绪的容器镜像（container image）。 buildpacks对你的应用提供框架和runtime支持。buildpacks检查你的应用，确定你应用所需的依赖并适当的配置它们以在任何云上运行。 buildpacks如何工作（原理）？ 每个buildpack包括两个阶段，detectphase，buildphase detect phase 侦测你的代码是否可以...
使用云原生buildpacks将你的代码转换成Docker Image | 技术干货
CSDN云计算
05-30 1048
戳蓝字“CSDN云计算”关注我们哦！技术头条：干货、简洁、多维全面。更多云计算精华知识尽在眼前，get要点、solve难题，统统不在话下！七年前buildpack技术开...
docker build run 卡住_不用Docker也能构建容器的4种方法
weixin_42514005的博客
12-15 1341
在本文，我将介绍几种不用 Docker 就可以构建容器的方法。我将以 OpenFaaS 作为参考案例，它的工作负载使用了 OCI 格式的容器镜像。OpenFaaS 是 Kubernetes 的一个 CaaS 平台，可以运行微服务和添加 FaaS 及事件驱动工具。第一个示例将展示如何使用 Docker CLI 内置的 buildkit 选项，然后是单独使用buildkit，最后是谷歌的容器构建器Ka...
弃用 Docker ！事实证明，它更牛逼。。。
最新发布
weixin_44421461的博客
05-14 179
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 Elast...
CMSIS-Packs.7z for S32DS / Eclipse Embedded.
07-18
在Eclipse环境下下载CMSIS-Packs经常进度条停止进行不下去。所以这里准备了下载好的CMSIS-Packs包，直接解压放置于C:\Users\???\AppData\Roaming文件夹下即可。
jumpserver-packs.tar.gz
08-15
本文将深入探讨基于"jumpserver-packs.tar.gz"的Jumpserver堡垒机的核心概念、功能及使用方法。 首先，我们需要了解"jumpserver-packs.tar.gz"这个文件。这是一个压缩包，包含了Jumpserver堡垒机的扩展包或插件集合...
gcf-packs：用于Google云功能的库包
01-31
gcf-packs 用于Google Cloud功能的库包 如何开始 将ZIP直接上传到您的云功能或Google Cloud Storage 当前包 SeleniumChrome 介绍 Chrome上的Selenium。 实际上-一种现成的用于网络抓取的工具。 例如，演示现在在...
vim-packs：vim 8nvim的命令行软件包管理器
02-04
包 用python编写的vim 8（或nvim）的轻量级命令行软件包管理器。安装mkdir ~ /.vim/pack/vpacks/optcd ~ /.vim/pack/vpacks/optgit...packs/vpacks.sh然后，您应该在路径中的目录中建立指向可执行文件的链接，例如： ln
使用Cloud Native Buildpacks构建应用程序的CLI-Golang开发
05-26
使用Cloud Native Buildpacks包构建应用程序的CLI-Buildpack CLI包使应用程序易于使用...应用开发人员可以使用buildpacks将代码转换为可运行的图像。 Buildpack开发和打包buildpack进行分发的作者。 运营商打包buildpack以分发和维护应用程序。 使用入门从教程开始：从源代码到图像贡献的应用程序简介之旅贡献-包括贡献请求过程在内的有关贡献方式的信息。 开发者
heroku-buildpack-scala:Heroku构建包
05-06
用于Scala的Heroku Buildpack 这是Scala应用程序的官方 。 这个怎么运作 如果构建包具有一个project/build.properties文件以及一个基于.sbt或.scala的构建配置（例如，一个build.sbt文件），则buildpack将把您的应用程序检测为Scala。 它在您的插件中提供了sbt版本（如果您不使用sbt-native-packager，它还将在您的插件中包含填充的.ivy/cache ）。 .ivy2目录将在构建之间缓存，以缩短构建时间。 强烈建议您在此buildpack中使用sbt-native-packager而不是sbt-start-script。 不建议使用后者，并且会导致塞子尺寸过大。 文献资料 有关在Heroku上使用Scala和buildpacks的更多信息，请参阅以下文章： 例子 有许多示例应用程序演示了配置项目以在H
buildstep:Buildstep使用Docker和Buildpacks构建诸如Heroku之类的应用程序
05-13
建造步骤 Heroku风格的应用程序使用Docker和Buildpacks构建。 制作了一个迷你的Heroku。 要求 码头工人 吉特 支持的构建包 Buildpack通常应该可以正常工作，但是其中许多都对其环境进行了假设。 因此，Buildstep具有内置且可以使用的。 建筑施工步骤 buildstep脚本使用需要构建的buildstep基本映像。 必须先创建它，然后才能使用buildstep脚本。 要创建它，请运行： $ make build 这将创建一个名为progrium/buildstep ，其中包含所有受支持的构建包以及将实际使用该构建包执行构建的构建器脚本。 建立一个应用程序 运行buildstep脚本将通过STDIN将应用程序tar和目标映像名称作为参数。 压缩包基于progrium/buildstep部署在新容器中，并且builder脚本在容器中运行。 然后，将容器
application_buildpack:使用 heroku buildpacks 部署和配置应用程序
07-01
application_buildpack 描述 本说明书旨在能够使用 heroku buildpacks 部署应用程序。 以下构建包经过测试和支持： Ruby 节点 请注意，此说明书基于application说明书； 您将在该说明书中找到一般文档。 要求 需要 Chef 11.0.0 或更高版本（用于 Chef 环境）。 以下 Opscode 说明书是依赖项： 资源/提供者 本说明书提供的 LWRP 不打算单独使用； 在继续之前，请确保您熟悉application说明书。 compile compile子资源 LWRP 处理使用 buildpack 编译应用程序。 属性参数 buildpack ：要使用的构建包。 将用于安装依赖项并设置 buildpack 存储库。 默认值： nil 。 选项: :ruby, :nodejs buildpack_repository ：应该使用
python-packs
03-21
综上所述，"python-packs-master"这个压缩包是一个全面的学习资源，涵盖了Python编程、数据科学、机器学习以及Jupyter Notebook的使用技巧。无论是初学者还是经验丰富的开发者，都能从中受益，提升自己的Python技能...
Docker学习总结（67）—— 取代 Dockerfile 的新型镜像构建技术 Buildpacks 详解
科技D人生
01-05 679
前言 云原生正在吞并软件世界，容器改变了传统的应用开发模式，如今研发人员不仅要构建应用，还要使用 Dockerfile 来完成应用的容器化，将应用及其依赖关系打包，从而获得更可靠的产品，提高研发效率。随着项目的迭代，达到一定的规模后，就需要运维团队和研发团队之间相互协作。运维团队的视角与研发团队不同，他们对镜像的需求是安全和标准化。比如： 不同的应用应该选择哪种基础镜像？ 应用的依赖有哪些版本？ 应用需要暴露的端口有哪些？ 为了优化运维效率，提高应用安全性，研发人员需要
无需依赖Docker环境制作镜像
huashetianzu的专栏
02-09 593
但是，要想通过平台类型的系统去为每个系统构建镜像，显然通过插件的方式，不太合适，因为需要每个被构建系统引入jib-maven-plugin插件才行，也就是需要改造每一个系统，这样就会带来一定的麻烦。，它是一个无需Docker守护进程——也无需深入掌握Docker最佳实践的情况下，为Java应用程序构建Docker和OCI镜像， 它可以作为Maven和Gradle的插件，也可以作为Java库。通过Jib-core，可以很轻松的实现镜像构建，而不需要依赖任何其他环境，也不需要被构建系统做任何改造，非常方便。
主机无网情况下如何不通过docker pull导入镜像
QianLiStudent的博客
07-01 1655
介绍       如果出现本机无网络的情况，要搜索下载网络资源简直就是天方夜谭。如果有另一台能通网的机器那么就不存在问题了，因为我们可以通过从通网的机器上下载到相应的资源文件，然后再拷贝或上传给网络不通的本机（如果你原本就有这些资源文件假设存在U盘，甚至都不需要网络了）。       这篇文章是介绍如何在本机网络不通的情况下直接使用docker压缩包进行安装：https://blog.cs
mdk-packs.jansson.2.7.0
04-29
mdk-packs.jansson.2.7.0是一个开源的C/C++ JSON解析器和生成器。JSON是JavaScript Object Notation的简称，是一种轻量级的数据交换格式，逐渐成为跨语言通信的标准格式。mdk-packs.jansson.2.7.0可以解析JSON数据，将其转换成内存中的对象或数组，也可以将内存中的对象或数组转换为JSON格式的字符串。mdk-packs.jansson.2.7.0支持许多操作，比如获取JSON对象的key或value、添加或删除JSON数组的元素等。使用mdk-packs.jansson.2.7.0可以更加方便快捷地处理JSON格式的数据，有助于提高程序的可读性和可维护性，同时也可以加快开发效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值