packer学习—用Docker构建器构建docker镜像

已于 2022-03-30 21:25:58 修改
阅读量1.9k 收藏 1
点赞数 2
分类专栏： 基础设施-运维 文章标签： linux bash 运维
于 2022-03-30 20:55:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45941099/article/details/123838526
版权

前言：packer是根据HCL模板构建容器镜像的
注：HCL2 模板最初是作为 Packer 版本 1.5 的 beta 功能引入的。从 v1.7 开始，HCL2 支持不再处于测试阶段，并且是编写 Packer 配置的首选方式。对于老式的稳定配置语言，请参阅模板文档。从 v1.6.2 开始，您可以使用 hcl2_upgrade 命令将旧 JSON 模板转换为 HCL2 配置文件。
所以只有1.5版本以后的packer才支持HCL模板

一、 安装packer

官方文档：Packer官方网站

1.Packer 可以通过以下方式安装：

  • 使用预编译的二进制文件。Packer官方为所有受支持的平台和架构发布二进制文件。建议大多数用户使用此方法。
  • 从源安装。此方法仅推荐给高级用户。
  • 使用系统的包管理器。

2.如何安装预编译的二进制文件

1.思路：

(1)要安装预编译的二进制文件，请为您的系统下载适当的软件包。 Packer 当前打包为 zip 文件。
(2)下载 Packer 后，解压缩包。 Packer 作为一个名为 packer 的二进制文件运行。(解压后可直接运行)
(3)最后，确保打包程序二进制文件在您的 PATH 中可用。(即将packer移动到你的系统环境变量PATH的目录下)
tip:如何确保打包程序二进制文件在您的 PATH 中可用
分两步：
①首先打印系统环境目录(环境位置以冒号隔开)：

echo $PATH
#测试
[root@zsh bin]# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin

②将 Packer 二进制文件移动到列出的位置之一。（此命令假定二进制文件当前位于您的下载文件夹中，并且您的 PATH 包含 /usr/local/bin，但如果您的位置不同，您可以自定义它）。

mv ~/Downloads/packer /usr/local/bin/
2.演示：这里在Linux系统中进行packer安装演示：

如何下载：不同平台的packer下载方法
①在centos7.9下安装packer，执行以下命令

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo
sudo yum -y install packer

②在进行yum安装完packer后，会自动进行解压，解压后的二进制文件就是packer。

#下载完packer的默认存储路径为/usr/bin/目录下
#如何查看是否下载安装包成功呢，列出所有安装包，用grep筛选
[root@zsh~]# rpm -qa|grep packer
packer-1.8.0-1.x86_64
#查看安装包路径
[root@zsh ~]# rpm -ql packer-1.8.0-1.x86_64
/usr/bin/packer

#现在将packer移动到/usr/local/bin/目录下
mv usr/bin/packer /usr/local/bin/

③将packer移动到/usr/local/bin/后，验证packer。

#命令：packer -v
#测试
[root@zsh bin]# packer -v
1.8.0
#或者直接输入packer
[root@zsh bin]# packer
Usage: packer [--version] [--help] <command> [<args>]

Available commands are:
    build           build image(s) from template
    console         creates a console for testing variable interpolation
    fix             fixes templates from old versions of packer
    fmt             Rewrites HCL2 config files to canonical format
    hcl2_upgrade    transform a JSON template into an HCL2 configuration
    init            Install missing plugins or upgrade plugins
    inspect         see components of a template
    plugins         Interact with Packer plugins and catalog
    validate        check that a template is valid
    version         Prints the Packer version

二、 构建docker镜像（Build Image）

安装 Packer 后，是时候构建您的第一个映像了，您将构建一个 Docker 容器。如果你没有安装 Docker，你可以在这里下载它Docker。

1.编写 Packer 模板

注意:编写Packer模板前要确认packer版本>=1.5,否则无法解析HCL语言

Packer 模板是一个配置文件，它定义了您要构建的映像以及如何构建它。 Packer 模板使用 Hashicorp 配置语言 (HCL)。

①创建一个名为 packer_tutorial 的新目录。该目录将包含本教程的 Packer 模板。

 mkdir packer_tutorial

②导航到packer_tutorial目录。

cd packer_tutorial

③创建一个文件 docker-ubuntu.pkr.hcl。

touch docker-ubuntu.pkr.hcl

④将以下 HCL 块添加到其中并保存文件。

这是一个完整的 Packer 模板，您将使用它来构建 Ubuntu Docker 映像。在以下部分中，您将更详细地查看此模板的每个块。

packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source = "github.com/hashicorp/docker"
    }
  }
}

source "docker" "ubuntu" {
  image  = "ubuntu:xenial"
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]
}

2.初始化 Packer 配置

1.packer init .
packer init .

Packer 将下载您在上面定义的插件。在这种情况下，Packer 将下载大于 0.0.7 版本的 Packer Docker 插件

3.格式化并验证您的 Packer 模板

1.格式化模板
packer fmt .
2.验证模板
packer validate .

4.构建 Packer 映像

1.构建镜像
packer build docker-ubuntu.pkr.hcl
2.列出所有镜像
docker images

5.过程演示图
目录结构
文件目录结构
HCL模板

构建镜像

三、使用配置器将软件安装和配置到您的映像（镜像）中

在上一教程中，您使用 Packer 创建了第一个容器映像。但是，您构建的映像实质上是重新打包了现有的 Docker 映像。 Packer 的真正实用性是自动配置，以便在将软件转换为映像之前在机器中安装和配置软件。

在本教程中，您将使用配置器设置环境变量并在 Docker 映像中创建文件。虽然定义环境变量和在 Docker 映像中创建文件只是一个小示例，但它应该让您了解 Packer 配置程序可以做什么

1.Prerequisite（先决条件）

本教程基于前面的教程继续操作，如果没有进行前面操作，请先进行以下操作。

①安装packer

②编写HCL模板

创建一个名为 packer_tutorial 的目录并将以下配置粘贴到名为 docker-ubuntu.pkr.hcl 的文件中。

packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source = "github.com/hashicorp/docker"
    }
  }
}

source "docker" "ubuntu" {
  image  = "ubuntu:xenial"
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]
}

③初始化Packer模板配置（pcaker init .）

packer init .

2.Add provisioner to template(将配置器添加到模板)

使用配置器可以让您完全自动化对镜像的修改。您可以使用 shell 脚本、文件上传以及与现代配置管理工具（例如 Chef 或 Puppet）的集成。

要编写您的第一个配置程序，请将以下块添加到您的 Packer 模板中，在构建块内部和源分配下方（即build内，source下方）

provisioner "shell" {
  environment_vars = [
    "FOO=hello world",
  ]
  inline = [
    "echo Adding file to Docker Container",
    "echo \"FOO is $FOO\" > example.txt",
  ]
}
#这个块定义了一个 shell 配置器，它在 shell 执行环境中设置一个名为 FOO 的环境变量，并运行 inline 属性中的命令。此配置程序将创建一个名为 example.txt 的文件，其中包含 FOO is hello world。

您的构建块应该为：

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]
  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }
}

添加后为：

packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source = "github.com/hashicorp/docker"
    }
  }
}
source "docker" "ubuntu" {
  image  = "ubuntu:xenial"
  commit = true
}
#构建器
build {
  name    = "learn-packer"
  #源分配
  sources = [
    "source.docker.ubuntu"
  ]
   provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }
}

3.Build image(构建修改后的镜像）

使用配置器构建镜像

packer build docker-ubuntu.pkr.hcl

操作过程
从packer的输出中可以清晰地看到进行的改动信息。

在输出中，您将找到使用 shell 脚本进行配置，确认 Packer 运行了配置步骤。注意 Packer 如何输出第一个内联命令（将文件添加到 Docker 容器）。

4.Verify update image（验证更新后的镜像）

通过使用 Docker 运行镜像来验证镜像。
①首先查找Image ID，并修改镜像标签(新建的镜像是没有REPOSITORY和TAG的，可以根据创建时间判断哪个是我们新建的镜像)

[root@zsh packer_tutorial]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
<none>        <none>    4637a109718e   13 minutes ago   135MB
<none>        <none>    f9d33370206f   11 hours ago     135MB
hello-world   latest    feb5d9fea6a5   6 months ago     13.3kB
ubuntu        xenial    b6f507652425   7 months ago     135MB
[root@zsh packer_tutorial]# docker tag 4637a109718e ubuntu_update:xenial_addfile
[root@zsh packer_tutorial]# docker images
REPOSITORY      TAG              IMAGE ID       CREATED          SIZE
ubuntu_update   xenial_addfile   4637a109718e   14 minutes ago   135MB
<none>          <none>           f9d33370206f   11 hours ago     135MB
hello-world     latest           feb5d9fea6a5   6 months ago     13.3kB
ubuntu          xenial           b6f507652425   7 months ago     135MB

②要验证配置器在新镜像中创建了 example.txt 文件，首先启动新创建的 Docker 镜像。在终端中将 IMAGE_ID 替换为上面显示的值（如上面的输出所示，本地等效于 4637a109718e）。

docker run -it IMAGE_ID
//测试，启动镜像后就会进入ubuntu容器,此时容器就是一个ubuntu操作系统实例（启动ubuntu容器实例，进入shell终端）
[root@zsh packer_tutorial]# docker run -it 4637a109718e
#

③在 Docker 容器Shell中，打印 example.txt 文件的内容。这应该返回 FOO is hello world 正如预期的那样。

cat example.txt

//测试
#启动添加了example.txt文件的镜像，生成Ubuntu容器实例
[root@zsh packer_tutorial]# docker run -it 4637a109718e
# ls
bin   dev  example.txt  lib    media  opt           proc  run   srv  tmp  var
boot  etc  home         lib64  mnt    packer-files  root  sbin  sys  usr
#  cat example.txt
FOO is hello world
#

过程截图如下：
启动ubuntu容器实例，进入shell终端
启动ubuntu容器实例，进入shell终端
④退出容器

exit

在这里插入图片描述

5.总结

  • 上面演示的 shell 配置器非常强大和灵活。对于复杂的配置，您可以传递整个 shell 脚本，而不是上面显示的内联声明。

  • 您可以根据需要运行任意数量的配置器。配置器按照声明的顺序运行。

  • 用以下内容替换现有的构建块。这会在构建块的末尾添加一个配置器，它将在 shell 执行环境中打印一条消息。

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = ["echo This provisioner runs last"]
  }
}

HCL模块分析

  • Build and verify updated image(构建并验证更新的镜像)

    再次构建镜像。

packer build docker-ubuntu.pkr.hcl

在这里插入图片描述
上面第二个配置器中仅显示预期的信息，没有执行其他操作，此时再查看又多了一个镜像

#查看镜像，最新的就是我们新构建的镜像。（最上面那个）
[root@zsh packer_tutorial]# docker images
REPOSITORY      TAG              IMAGE ID       CREATED         SIZE
<none>          <none>           d1d39530765d   3 minutes ago   135MB
ubuntu_update   xenial_addfile   4637a109718e   2 hours ago     135MB
<none>          <none>           f9d33370206f   13 hours ago    135MB
hello-world     latest           feb5d9fea6a5   6 months ago    13.3kB
ubuntu          xenial           b6f507652425   7 months ago    135MB

四、Variables变量

  • 在上一个教程中，您实现了第一个配置器。但是，您的 Packer 模板是静态的。目前如果你想改变文件的内容，你需要手动更新你的模板。

  • 您可以使用输入变量作为 Packer 构建的参数，允许在不更改 Packer 模板的情况下自定义构建的各个方面。此外，当您想要在整个模板中引用特定值时，Packer 变量很有用。

  • 在本教程中，您将添加 Packer 变量来参数化您的 Packer 构建，使其更加健壮。

  • 总结：就是将packer模板中的参数用变量替代，没有写死，在需要更改的时候直接改变量的值

  • 此外，当您想要在整个模板中引用特定值时，Packer 变量很有用。

  • 在本教程中，您将添加 Packer 变量来参数化您的 Packer 构建，使其更加健壮。

  • 总结：就是将packer模板中的参数用变量替代，没有写死，在需要更改的时候直接改变量的值

1.Prerequisites(先决条件)

本教程假设您从前面的教程继续学习。如果没有执行，执行2.3的先决条件中的操作。

①安装packer

②编写HCL模板

创建一个名为 packer_tutorial 的目录并将以下配置粘贴到名为 docker-ubuntu.pkr.hcl 的文件中。

packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source = "github.com/hashicorp/docker"
    }
  }
}

source "docker" "ubuntu" {
  image  = "ubuntu:xenial"
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = ["echo This provisioner runs last"]
  }
}

③初始化Packer模板配置（pcaker init .）

packer init .

2.Add variable to template(将变量添加到模板)

将以下变量块添加到您的 docker-ubuntu.pkr.hcl 文件中。

variable "docker_image" {
  type    = string
  default = "ubuntu:xenial"
}

变量块声明变量名称（docker_image）、数据类型（字符串）和默认值（ubuntu:xenial）。虽然变量类型和默认值是可选的，但我们建议您在创建新变量时定义这些属性。

将 Packer 变量视为常量——您不能在运行时更新它们。

在您的 Packer 模板中，更新您的源代码块以引用 docker_image 变量。请注意模板如何将变量引用为
var.docker_image（通过var.变量名来引用变量）
在这里插入图片描述
更新第二个配置器以打印 docker_image 变量。请注意，即使在上面的源代码块中直接使用了 docker_image 变量，要将变量嵌入到另一个字符串中，您需要使用语法 ${} 对其进行模板化，如在配置程序块中回显 docker_image 时所示。
在这里插入图片描述

添加后模板如下：

packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source = "github.com/hashicorp/docker"
    }
  }
}
#定义变量块
variable "docker_image" {
  type    = string
  default = "ubuntu:xenial"
}

source "docker" "ubuntu" {
  image  = var.docker_image
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu"
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = [
    "echo Running ${var.docker_image} Docker image.",
    "echo \"${var.docker_image} is run\" > example.txt",]
  }
}

在这里插入图片描述
在这里插入图片描述

3.Build image(构建镜像）

packer build docker-ubuntu.pkr.hcl

在这里插入图片描述
在这里插入图片描述

4.Build image with variables(用变量构建镜像像)

由于 docker_image 是参数化的，因此您可以在构建映像之前定义变量。有多种分配变量的方法。升序优先顺序是：变量默认值、环境变量、变量文件、命令行标志。在本节中，您将使用变量文件和命令行标志定义变量。
注意：有多种分配方式存在时，优先级高的覆盖优先级低的，如命令行标志优先变量文件分配变量（同一个变量被多次赋值，优先级高的方式会替换优先级低的）

1.使用变量文件构建映像

①创建一个名为 example.pkrvars.hcl 的文件。(docker_image 的值由变量文件定义。)

touch example.pkrvars.hcl

将以下代码段添加到其中。

docker_image = "ubuntu:bionic"

使用 --var-file 标志构建镜像。

packer build --var-file=example.pkrvars.hcl docker-ubuntu.pkr.hcl

在这里插入图片描述
②Packer 将自动加载与名称*.auto.pkrvars.hcl匹配的任何变量文件，而无需通过命令行传递文件。

重命名变量文件，以便 Packer 自动加载它。

mv example.pkrvars.hcl example.auto.pkrvars.hcl

构建镜像并注意运行 ubuntu:bionic 的 Docker 镜像。packer构建。命令加载当前目录中的所有内容。

packer build .
2.使用命令行标志构建映像

构建映像，直接从命令行设置变量。

packer build --var docker_image=ubuntu:groovy .
#命令行标志具有最高优先级，并将覆盖其他方法定义的值。

过程图：
在这里插入图片描述

Next Steps

在本教程中，您通过使用变量对其进行参数化，使您的 Packer 模板更加健壮。然后，您在构建步骤中使用变量文件和命令行标志定义了变量，学习了过程中变量定义的优先顺序。继续下一个教程，使用同一模板并行创建多个图像。

五、Parallel Builds并行构建

在之前的教程中，您使用 Packer 自动构建镜像并从模板进行配置。然后，您将模板参数化，允许您使用相同的模板构建不同的镜像。虽然这已经非常强大，但 Packer 可以并行创建多个镜像，所有镜像都从一个模板进行配置。

并行构建是 Packer 的一个非常有用且重要的特性。例如，Packer 可以使用相同的脚本并行构建 Amazon AMI 和 VMware 虚拟机，从而生成几乎相同的映像。 AMI 可用于生产，VMware 机器可用于开发。或者，另一个示例，如果您使用 Packer 构建软件设备，那么您可以为每个支持的平台并行构建设备，并从单个模板进行配置。

在本教程中，您将并行构建第二个 Docker 镜像。虽然在本教程中第二个镜像是一个 Docker 镜像，但第二个源可以很容易地来自另一个管理程序或云平台。

1.先决条件

本教程假设您从前面的教程继续学习。如果没有，请在继续之前按照以下步骤操作。

  • Install Packer

  • 创建一个名为 packer_tutorial 的目录并将以下配置粘贴到名为 docker-ubuntu.pkr.hcl的文件中。

    packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source  = "github.com/hashicorp/docker"
    }
  }
}

variable "docker_image" {
  type    = string
  default = "ubuntu:xenial"
}

source "docker" "ubuntu" {
  image  = var.docker_image
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu",
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = ["echo Running ${var.docker_image} Docker image."]
  }
}

  • 初始化 Packer 模板。

    packer init .

    成功初始化模板后，您可以继续本教程的其余部分。

2.将并行构建添加到模板

To use parallel builds, create a source then add the source to the sources array in the build block. Your sources do not need to be the same type. This tells Packer to build multiple images when that build is run.

要使用并行构建，请创建一个源，然后将源添加到构建块中的源数组。您的源不需要是相同的类型。这告诉 Packer 在构建运行时构建多个镜像(一个源构建一个镜像，多个不同的源即同时构建多个不同的镜像)。

将以下源代码块添加到您的 docker-ubuntu.pkr.hcl 文件中。不要替换现有的 ubuntu 源；在下面添加它。
在这里插入图片描述

source "docker" "ubuntu-bionic" {
  image  = "ubuntu:bionic"
  commit = true
}

然后在Packer模板中更新您的构建块(Build)以使用新源(source)。
在这里插入图片描述

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu",
    "source.docker.ubuntu-bionic",
  ]
  ## ...
}

docker-ubuntu.pkr.hcl文件的改动结果图：
在这里插入图片描述

3.Build images(构建镜像)

packer build .

构建镜像。 Packer 将显示两个版本的颜色编码输出。您可以使用行颜色或前缀来判断输出行与哪个构建源相关联。在此示例中，有两个构建：docker.ubuntu 和 docker.ubuntu-bionic。（两颜色种日志交叉显示——并行构建）
在这里插入图片描述

Next Steps

在本教程中，您更新了模板以并行构建多个镜像。继续下一个教程，为您的 Packer 模板添加一个后处理步骤。

六、 Post-Processors（后处理器）

在上一个教程中，您更新了模板以并行构建多个镜像。

虽然在实例运行时对实例运行配置程序，但后处理器仅在 Packer 将实例保存为镜像后运行。后处理器的功能极其多样。他们可以压缩您的工件，将您的工件上传到云中，或者创建一个描述工件和构建的文件。

在本教程中，您将添加 docker-tag 后处理器以向 Docker 映像添加标签。

总结：配置器是在packer进行构建镜像的时候运行配置程序，而后处理器则是镜像构建成功后，对镜像进行处理。

1.先决条件

本教程假设您从前面的教程继续学习。如果没有，请在继续之前按照以下步骤操作。

  • Install Packer
  • 创建一个名为 packer_tutorial 的目录并将以下配置粘贴到名为 docker-ubuntu.pkr.hcl 的文件中。
packer {
  required_plugins {
    docker = {
      version = ">= 0.0.7"
      source  = "github.com/hashicorp/docker"
    }
  }
}

variable "docker_image" {
  type    = string
  default = "ubuntu:xenial"
}

source "docker" "ubuntu" {
  image  = var.docker_image
  commit = true
}

source "docker" "ubuntu-bionic" {
  image  = "ubuntu:bionic"
  commit = true
}

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu",
    "source.docker.ubuntu-bionic",
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = ["echo Running ${var.docker_image} Docker image."]
  }
}
  • 初始化 Packer 模板。
packer init .

成功初始化模板后，您可以继续本教程的其余部分。

2.Add post-processor to template(将后处理器添加到模板)

在构建块内但在配置器步骤之后添加以下后处理器块。这些后处理器块将使用适当的标签标记每个镜像。

(即在build内，provisioner之后)

post-processor "docker-tag" {
  repository = "learn-packer"
  tags       = ["ubuntu-xenial", "packer-rocks"]
  only       = ["docker.ubuntu"]
}

post-processor "docker-tag" {
  repository = "learn-packer"
  tags       = ["ubuntu-bionic", "packer-rocks"]
  only       = ["docker.ubuntu-bionic"]
}

您的构建块应如下所示。

build {
  name    = "learn-packer"
  sources = [
    "source.docker.ubuntu",
    "source.docker.ubuntu-bionic",
  ]

  provisioner "shell" {
    environment_vars = [
      "FOO=hello world",
    ]
    inline = [
      "echo Adding file to Docker Container",
      "echo \"FOO is $FOO\" > example.txt",
    ]
  }

  provisioner "shell" {
    inline = ["echo Running ${var.docker_image} Docker image."]
  }

  post-processor "docker-tag" {
    repository = "learn-packer"
    tags       = ["ubuntu-xenial", "packer-rocks"]
    only       = ["docker.ubuntu"]
  }

  post-processor "docker-tag" {
    repository = "learn-packer"
    tags       = ["ubuntu-bionic", "packer-rocks"]
    only       = ["docker.ubuntu-bionic"]
  }
}
#注：从这里可以看出一共有四个标签，然后后两个一样，所以最后有三个标签的镜像，第二后处理器的生成的带有标签的镜像会替换前面一样标签的镜像

在这里插入图片描述

3.Build and tag images（构建和标记镜像）
packer build .

没添加后处理器之前生成的镜像：
在这里插入图片描述
添加后处理器之后的镜像：

在这里插入图片描述
在这里插入图片描述

4.Sequential post-processing steps（后处理步骤顺序）

您可以使用后处理器语法添加任意数量的后处理器，但每个后处理器都将从构建器输出的原始工件开始，而不是从先前声明的后处理器创建的工件开始。

使用后处理器（注意复数）块创建后处理管道，其中一个后处理器的输出成为另一个后处理器的输入。

例如，以下配置将标记您的镜像，然后将其推送到 Docker Hub。您不需要将此添加到本教程的配置中，因为它需要 Docker 帐户并将您的镜像推送到 Docker Hub

post-processors {
  post-processor "docker-import" {
    repository = "swampdragons/testpush"
    tag        = "0.7"
  }
  post-processor "docker-push" {}
}

请注意，您可以根据需要添加任意数量的后处理器块，或者将一次性后处理器与后处理器块混合搭配，以创建多个后处理路径。
在这里插入图片描述

花了三天的时间，终于把如何用packer构建docker镜像的全过程肝下来了，希望对大家有帮助哈，也是我自己的一个笔记记录。

西里小诸葛
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
packer-on-github：使用GitHub Actions使用Packer构建机器映像
02-09
试验GitHub Actions以使用Packer构建机器映像。 理想情况下，尝试弄清楚在GitHub Actions上构建以下内容需要做什么： VirtualBox ISO 超V ISO Docker镜像 Docker镜像 基本情况。 我想确认我实际上可以使用GitHub...
docker-postfix:用于Postfix的Docker映像打包
03-13
由Packer Docker构建器和Ansible Provisioner打包在单层中 用处理ENTRYPOINT 快速开始 启动后缀： # Pull latest image docker pull alvistack/postfix # Run as detach docker run \ -itd \ --name postfix \ ...
玩转云镜像制作之packer篇
weixin_33847182的博客
03-25 776
1.DevOps之基础设施即代码(Infrastracture as Code) 什么是DevOps呢？按照维基百科的定义，DevOps（Development和Operations的组合词）是一种重视“软件开发人员（Dev）”和“IT运维技术人员（Ops）”之间沟通合作的文化、运动或惯例。透过自动化“软件交付”和“架构变更”的流程，来使...
使用 Packer 创建自定义镜像
a_small_cherry的博客
02-20 481
简介：Packer是一款轻量级的镜像定义工具，能够运行在常用的主流操作系统（如Windows、Linux和macOS）上。本文主要为大家讲解如何安装并使用Packer，轻松创建自定义镜像。 镜像下载、域名解析、时间同步请点击阿里巴巴开源镜像站 背景信息 本文描述以Linux系统的服务器为例，Windows系统的操作请参见Packer官方文档。 一、安装Packer 1、连接并登录到Linux服务器。登录ECS Linux实例服务器，请参见使用用户名密码验证连接Linux实例。 2、执...
推荐使用Packer：高效且跨平台的机器镜像构建工具
最新发布
gitblog_00074的博客
05-10 329
推荐使用Packer：高效且跨平台的机器镜像构建工具 项目地址:https://gitcode.com/hashicorp/packer 在如今的云计算时代，快速、可靠地创建和部署一致性的机器镜像变得至关重要。这就是Packer大展拳脚的地方。作为一个强大的自动化工具，Packer允许您从单一源配置构建多平台的机器映像，包括Docker容器和各种云提供商的虚拟机。让我们一起深入了解这个开源项目，...
DevOps专题|Packer使用教程
京东科技开发者
01-09 2680
什么是Packer 简单介绍一下自己 Packer 是一个轻量命令行工具, 能在几乎所有主流的操作系统上运行。 在给定一份配置文件的情况下, Packer 能为多种系统架构创建云主机镜像。同时 Packer 自身也能够做到多镜像并发创建, 大大节省了镜像创建过程中的时间成本。 为什么要用 Packer 为什么呢？ 当然是因为使用预制的镜像有非常多的好处, 最简单来说，就是能最大程度地保证不同机器...
Packer 之Docker Builder
XUE_KEN的博客
02-28 1443
The docker Packer builder builds Docker images using Docker. The builder starts a Docker container, runs provisioners within this container, then exports the container for reuse or commits the image. ...
4 个超实用的 Docker 镜像构建技巧
easylife206的专栏
07-15 1492
公众号关注「奇妙的 Linux 世界」设为「星标」，每天带你玩转 Linux ！本文转自卡瓦邦噶，原文：https://www.kawabangga.com/posts/4676，版权归原作者所有。最近做了一个好玩的工具，叫xbin.io[1]。其中有一项工作是为不同的工具来构建 Docker 镜像，让他们都运行在 Docker 中（实际上，是兼容 Docker ...
packer-graphite:为 Graphite 构建的 Packer.io。 它生成一个 AWS AMI 和或一个 Docker 镜像
06-27
要使用它，请键入： ./build.sh或者 ./build.sh amazon-ebs或者 ./build.sh docker或者 ./build.sh digitalocean您还可以通过提供逗号分隔列表来使用多个构建器。 例如，键入以下内容将生成 Docker 和
packer-puppet-docker-example
06-02
使用 packer/puppet/r10k 构建 docker 容器的示例安装 r10k bundle install安装人偶文件 cd puppet/r10k puppetfile install设置将 docker 镜像导出到 docker hub 的环境在 repo 的顶部创建一个类似于以下内容的 set...
devops:基于 Vagrant 的 Virtualbox 设置构建打包镜像、go 文件和 docker 容器
06-04
基于 Vagrant 的 Virtualbox 设置构建打包镜像、go 文件和 docker 容器。 用法 在开始之前，请务必安装 Virtualbox 和 Vagrant。 如果你还没有设置你的机器进行开发，你可以在使用我们的 OSX 设置脚本 将此 repo ...
node-packer windows 安装包
01-07
将nodejs应用打包成单个可执行文件的工具。压缩包内包含windows平台下的安装包和依赖。
Packer 简要使用说明
dongsong1117的专栏
04-21 1238
文档：https://developer.hashicorp.com/packer/docs通过模板定义配置，使用插件构建 AWS、Azure、GCP、阿里云、华为云、腾讯云等多种云或 Saas 平台系统镜像的开源工具，可用外部插件配置文档：https://developer.hashicorp.com/packer/plugins下载地址，页面已包含各种系统安装说明：https://developer.hashicorp.com/packer/downloads CentOS/RHEL Amazo
Oracle Cloud Infrastructure（OCI）使用Packer创建客户化Image实战
engchina的专栏
04-01 460
Oracle Cloud Infrastructure（OCI）使用Packer创建客户化Image实战。 前提： a，拥有Oracle Cloud Infrastructure（OCI）账户 b，拥有Oracle Cloud Infrastructure（OCI）基础知识 详细步骤： 1，下载安装Packer，确认 1-1，下载安装Packer wget https://r...
packer build命令选项参数
allway2的博客
12-23 556
build命令 跳转到部分 该packer build命令采用模板并运行其中的所有构建以生成一组工件。除非另有说明，否则在模板中指定的各种构建是并行执行的。并且创建的工件将在构建结束时输出。 »选项 -color=false- 禁用彩色输出。默认启用。 -debug- 禁用并行化并启用调试模式。调试模式标记构建器他们应该输出调试信息。调试模式的确切行为由构建器决定。一般来说，建造者通常会在每一步之间停下来，等待键盘输入后再继续。这将允许用户检查状态等。 -except=foo,.
docker更新镜像
xiaofeixia666888的博客
09-22 1253
1.用旧镜像创建一个容器。2.在容器内安装需要的包。3.docker提交镜像。4.给镜像打一个新的标签。
Docker 简单使用
fy291021851的博客
12-10 666
一 docke简介 Docker 是一个开源的应用容器引擎，可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，在不同的机器中使用。 Docker 包括三个基本概念 镜像（Image） 就相当于是一个 root 文件系统 容器（Container） 容器可以被创建、启动、停止、删除、暂停等 仓库（Repository） 仓库可看成一个代码控制中心，用来保存镜像 Docker 容器通过 Docker 镜像来创建，容器与镜像的关系类似于面向对象编程中的对象与类 Docker镜像跨...
docker镜像生成有几种方式
04-01
1. 从Dockerfile构建镜像：使用Dockerfile定义镜像的配置和依赖，然后使用docker build命令构建镜像。 2. 从现有的容器生成镜像：使用docker commit命令将现有的容器转换为镜像。 3. 从压缩包生成镜像：使用docker...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

西里小诸葛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值