Packer: Use HCL

cc @pandacalculus

HCL está chegando: smile:

@delitescere Este problema não é uma duplicata do # 283? Percebi que você ligou a ele na postagem inicial, mas não está claro qual é a diferença entre os dois problemas.

Aqui, as chaves desconhecidas seriam tratadas de forma diferente de como são agora. Isso propõe chaves do tipo "comentário" que são ignoradas. O comentário é indicado por um prefixo de comentário de fechamento automático geralmente conhecido (viz: # , // , ; )

Foi uma sugestão alternativa dada a mudança de código maior para oferecer suporte a comentários em JSON não padrão, ou JSON5 ou YAML ou HCL.

O comentário de @sethvargo sobre a mudança para oferecer suporte à HCL resolve o problema.

@sethvargo

HCL está chegando: smile:

Desculpe incomodá-lo, alguma atualização sobre isso?

Ainda está chegando: sorria:

Decidimos atrasar um pouco, já que ainda não temos um gravador de HCL e gostaríamos de manter packer fix como uma opção para as próximas versões.

Eu bebi o Kool-aid HCL. : +1:

Agora que https://github.com/hashicorp/hcl existe, podemos obter uma alternativa para json? :)

@jevonearth que existe há muito tempo: smile :

Já que ainda está chegando, este é um bom momento para incluir arquivos de solicitação de recurso? consulte https://github.com/mkheironimus/packergen

@jevonearth aqui está uma alternativa até adicionar hcl

ainda vem em breve?

@mitchellh @sethvargo é este o escritor da HCL que você mencionou: https://github.com/hashicorp/hcl/tree/master/hcl/printer

Esperando por YAML. Não gosto muito de HCL

É meio trivial envolver o empacotador com uma função bash e converter yaml em json .

Para começar:

ruby -r json -r yaml -e "yaml = YAML.load(File.read(\"$1\")); print yaml.to_json"

(e o inverso)

ruby -r json -r yaml -e "json = JSON.parse(File.read(\"$1\")); print YAML::dump(json)"

Eu já fiz isso. Seria bom não precisar. É por isso que este tíquete existe para HCL

Em 16 de janeiro de 2017, às 12h31, Rickard von Essen [email protected] escreveu:

É meio trivial envolver o packer com uma função bash e converter yaml em json.

Para começar:

ruby -r json -r yaml -e "yaml = YAML.load (File.read (\" $ 1 \ ")); imprimir yaml.to_json"
(e o inverso)

ruby -r json -r yaml -e "json = JSON.parse (File.read (\" $ 1 \ ")); imprimir YAML :: dump (json)"
-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub ou ignore a conversa.

HCL

A HashiCorp precisa mostrar um pouco de fé em si mesma e usar a HCL em todos os lugares que puder. Ou o HCL foi uma boa ideia e eles deveriam funcionar com ele, ou o HCL foi um erro e o Terraform é um desastre. Claramente, o último não é verdade. Portanto, como um novo avaliador / adotante, devo dizer que é preocupante que esses 2 produtos pareçam "duas agências de inteligência que não se comunicam".

Estou com @sethvargo. Vamos vestir nosso sigilo de lobo gigante e proclamar que "HCL está chegando". (Não só isso, também faça acontecer.)

JSON

Não há necessidade de fazer alterações nos comentários de calçadeira no JSON. A solução nos foi dada por Douglas Crockford e exemplificada por Nicholas Chammas em The Notorious Two Eight Three https://github.com/mitchellh/packer/issues/283#issuecomment -60039068

YAML

Os mineiros de Ruby adoram um pouco de YAML e nos deram uma solução para usá-lo desde o início. Isso foi maravilhosamente exemplificado por Rickard von Essen 2 comentários atrás https://github.com/mitchellh/packer/issues/1768#issuecomment -272921740 (embora eu prefira usar ARGF.read como faço abaixo)

Et cetera

Adoro o fato de a HashiCorp tornar mais fácil usar tantos ou poucos produtos quanto você precisar. Ele se encaixa bem com a filosofia unix (conforme resumido por Peter H. Salus em A Quarter-Century of Unix (1994)):

• Escreva programas que façam uma coisa e a façam bem.
• Escreva programas para trabalharem juntos.
• Escreva programas para lidar com fluxos de texto, porque essa é uma interface universal.

Devemos estar bem com:

JSON

$ cat > example.json <<'EOF'
// from: https://www.packer.io/intro/getting-started/vagrant.html
{
    // can't we take this out?
    "variables": {
        "aws_access_key": "", // why is this blank?
        "aws_secret_key": ""  // ditto
    },
    "builders": [{
        "type": "amazon-ebs",
        "access_key": "{{user `aws_access_key`}}",
        "secret_key": "{{user `aws_secret_key`}}",
        "region": "us-west-2",
        "source_ami": "ami-b7a114d7",
        "instance_type": "t2.micro",
        "ssh_username": "ubuntu",
        "ami_name": "packer-example {{timestamp}}",
        "tags": {
            "created_by": "Packer.io/example"
        }
    }],
    "provisioners": [{
        "type": "shell",
        "inline": [
            "sleep 30",
            "sudo apt-get update",
            "sudo apt-get install -y redis-server"
        ]
    }],
    "post-processors": ["vagrant"]
}
EOF

$ packer validate <(jsmin < example.json)
Template validated successfully.

YAML

$ cat > example.yaml <<'EOF'
---
# from: https://www.packer.io/intro/getting-started/vagrant.html

# can't we take this out?
variables:
  aws_access_key: '' # why is this blank?
  aws_secret_key: '' # ditto

builders:
- type: amazon-ebs
  access_key: '{{user `aws_access_key`}}'
  secret_key: '{{user `aws_secret_key`}}'
  region: us-west-2
  source_ami: ami-b7a114d7
  instance_type: t2.micro
  ssh_username: ubuntu
  ami_name: packer-example {{timestamp}}
  tags:
    created_by: Packer.io/example

provisioners:
- type: shell
  inline:
  - sleep 30
  - sudo apt-get update
  - sudo apt-get install -y redis-server

post-processors:
- vagrant
EOF

$ packer validate <(ruby -r json -r yaml -e "print YAML.load(ARGF.read).to_json" < example.yaml)
Template validated successfully.

Estou criando um pequeno pr para modelos yaml, para meus testes limitados funciona bem para mim.

Definitivamente, algo que planejamos investigar. Por enquanto, porém, uma vez que não estamos almejando isso para 1.0, vou encerrar isso. Por favor, consulte a lista de discussão para obter mais detalhes sobre 1.0.

É hora de reabrir a edição. Definitivamente, HCL deve ser o idioma de configuração padrão no Packer.

PS: Ainda não tenho ideia do por que quase todos os problemas foram fechados, há projetos, marcos e tags para gerenciar os problemas.

Isso é algo que estamos planejando fazer. Como é uma revisão tão ampla, queremos ter certeza de que a faremos bem. A próxima etapa para nós é passar por nosso processo de RFC, que seria sobre um problema separado.

Congratulo-me com JSON5, YAML e HCL. JSON puro é doloroso.

@ darkn3rd Sentimos sua dor e é doloroso o suficiente para que nós, Joyent, mantenham um branch JSON5 que rastreia master porque a situação atual é insustentável para quem realmente usa e mantém qualquer quantidade real de modelos de empacotador: https: //github.com/joyent/packer/tree/f-json5

/ me faz uma nota mental para atualizar o ramo esta semana

Estamos próximos de 3 anos de "em breve" ... Sou um iniciante em packer e estou surpreso, para dizer o mínimo, que ele não suporte HCL. Mal posso esperar para testá-lo.

Acabei de dizer ao meu amigo "hey lat's migrar aquele json horrível para HCL, é uma ferramenta hashicorp, certo?". Quão errado eu estava ...

Se for de interesse, yacker (um utilitário Python) envolve o Packer em um interpretador YAML para JSON. Não é nada surpreendente - ele apenas fornece um invólucro YAML que converte arquivos de modelo e variáveis ​​temporariamente em JSON antes de passar o controle para o Packer.

https://yacker.readthedocs.io/en/latest/

Equipe do empacotador? Por que você ainda não fornece HCL? Estou criando um pequeno patch para suporte a YAML quase mais de um ano atrás, que funciona bem e você rejeita com razão, que a HCL está chegando. Mas depois de um ano nada mudou!
O que você diz?

Ainda vindo: piscadela:

@vtolstov veja # 7023

O pessoal de produto interno da HashiCorp decidiu que vamos pular direto o HCL1 e implementar o HCL2; desculpe, isso nunca foi implementado, mas prometo que estamos trabalhando ativamente no suporte HCL2 agora.

Obrigado pela atualização. Não desistimos disso.

Obrigado @SwampDragons! Visto que isso está sendo trabalhado ativamente, esse problema deve ser reaberto?

Bom ponto; ele foi fechado acidentalmente quando fechamos o PR associado sem fundir.

Muito animado para o suporte HCL2 com packer!

@SwampDragons Alguma notícia sobre a HCL, por favor?

Esperamos (mas não prometemos) lançá-lo com o lançamento 1.5.0. A equipe tem um protótipo de trabalho em um branch, mas ainda não está polido ou endurecido e, com @azr prestes a sair de licença parental, podemos acabar tendo que escorregá-lo um pouco mais tarde. A meta é até o final do ano, de preferência mais perto de setembro do que de dezembro.

Voltei depois de alguns anos e fiquei surpreso que ainda estava aberto.
Ainda bem que está a caminho em 1.5.

@SwampDragons Você tem algum cronograma aproximado para quando o 1.5.0 estará disponível (mesmo como um beta)?

Se a mudança for complicada (e pode haver boas razões para isso), então não é um risco e custo de desenvolvimento muito menor deixar uma ferramenta perfeitamente boa sozinha e, em vez disso, em vez de alterar o formato de definição principal, forneça _adaptadores_ que convertem format-X para JSON?

Apenas um pensamento.

Não quero banalizar o problema e você pode ter motivos realmente importantes para alterar o formato principal, mas, considerando o tempo e esforço que está sendo gasto nisso, se é apenas sobre como os usuários definem seus arquivos, então, como um projeto, é há necessidade de _adaptadores de idioma_ como o yacker ?

@alanbchristie Para ser justo, não foi trabalhado ativamente todo esse tempo; tem sido uma questão de segundo plano "devemos pensar sobre isso" por muito tempo, mais recentemente porque queríamos assistir e ver como o lançamento do HCL2 foi com o Terraform 0.12 para que pudéssemos aprender com o processo antes de tentarmos fazer novamente nós mesmos . Não acho que será um processo tão árduo quanto foi para o Terraform, mas não posso falar em detalhes porque, como disse, é um projeto no qual @azr estava trabalhando e ele está experimentando a felicidade dos pais no momento. ;) Quando ele voltar, vou perguntar se ele pode escrever uma pequena atualização de progresso para vocês.

@NickLarsenNZ O roteiro que mostro ao meu chefe diz em algum momento por volta de outubro ou novembro. Se você quiser, posso enviar um ping assim que tivermos uma versão testável.

Eu sou novo no packer ... mas vou ser honesto, o fato de que este tem sido um problema não resolvido por 5-6 anos não é apenas bastante desanimador, mas extremamente frustrante.

Usar jq para remover comentários enquanto uma solução alternativa significa que provavelmente há 99 comentários que não foram escritos para cada 1 comentário escrito com jq para remover.

Eu poderia continuar por dias como json, conforme implementado pelo packer, não é adequado para esta tarefa, mas o fato de não permitir comentários e encorajar a duplicação de código / configuração (por que é que sinto que preciso escrever um packer json pseudo-compilador para permitir a reutilização de configuração).

Travado para reduzir o ruído; @azr está de volta e farei com que ele dê uma atualização sobre esse problema, incluindo o fornecimento de compilações beta, quando tiver uma chance.

Olá pessoal ! Tenho boas notícias 🎉 😃

Recentemente, levei algum tempo para fazer a mudança do HCL2 acontecer e você pode encontrar um PR implementando-o aqui: # 8423. Alguns binários podem ser encontrados aqui .
Estamos fazendo o nosso melhor para testar vários casos diferentes para evitar bugs, mas há muitos construtores / provisionadores / pós-processadores e somos uma equipe pequena, então qualquer ajuda será muito bem-vinda para testar isso! Se você tentar fazer isso e encontrar um bug; abra um novo problema informando que é um bug da HCL.

A forma atual (antiga) de configurar o Packer continuará funcionando e atualmente planejamos oferecer suporte total às duas versões por um tempo, até que nos sintamos confiantes o suficiente para descontinuar a antiga.

build {
    sources = [
        "source.amazon-ebs.first",
    ]

    provisioner "shell" {
        inline = [
            "sleep 5"
        ]
    }

    post-processor "shell-local" {
        inline = [
            "sleep 5"
        ]
    }
}

source "amazon-ebs" "first" {
    // access_key = "{{user `aws_access_key`}}"
    // secret_key = "{{user `aws_secret_key`}}"

    ami_name = "hcl2-test"
    region = "us-east-1"
    instance_type = "t2.micro"

    kms_key_id = "c729958f-c6ba-44cd-ab39-35ab68ce0a6c"
    encrypt_boot = true
    source_ami_filter {
        filters {
          virtualization-type = "hvm"
          name =  "amzn-ami-hvm-????.??.?.????????-x86_64-gp2"
          root-device-type = "ebs"
        }
        most_recent = true
        owners = ["amazon"]
    }
    launch_block_device_mappings {
        device_name = "/dev/xvda"
        volume_size = 20
        volume_type = "gp2"
        delete_on_termination = "true"
    }
    launch_block_device_mappings {
        device_name = "/dev/xvdf"
        volume_size = 500
        volume_type = "gp2"
        delete_on_termination = true
        encrypted = true
    }

    ami_regions = ["eu-central-1"]
    run_tags {
        Name = "packer-solr-something"
        stack-name = "DevOps Tools"
    }

    communicator = "ssh"
    ssh_pty = true
    ssh_username = "ec2-user"
    associate_public_ip_address = true
}

PS: manipulação de documentos e variáveis ​​estão chegando!

Esta é uma ótima notícia, @azr , graças a você e à equipe.

WRT: descontinuando JSON.
É certo que você planeja alavancar o suporte JSON embutido do HCL / HCL2?

Existe um conversor json2hcl? Eu fiz scripts de empacotador bem no Netflix OSS que adoraria converter para HCL.

Olá a todos, estou entusiasmado com esta mudança!

@ darkn3rd Estou pensando em fazer um conversor específico de empacotador para que os usuários possam experimentá-lo rapidamente sem muito trabalho de copiar, colar e editar.

@mexisme A biblioteca HCL compreende totalmente JSON, mas o formato foi alterado um pouco, portanto,

⚠️ meu primeiro exemplo mudou e se parece um pouco mais com a terraform.

build {
    sources = [
        "source.amazon-ebs.first",
    ]

    provisioner "shell" {
        inline = [
            "sleep 5"
        ]
    }

    post-processor "shell-local" {
        inline = [
            "sleep 5"
        ]
    }
}

source "amazon-ebs" "first" {
    // access_key = "{{user `aws_access_key`}}"
    // secret_key = "{{user `aws_secret_key`}}"

    ami_name = "hcl2-test"
    region = "us-east-1"
    instance_type = "t2.micro"

    kms_key_id = "c729958f-c6ba-44cd-ab39-35ab68ce0a6c"
    encrypt_boot = true
    source_ami_filter {
        filters {
          virtualization-type = "hvm"
          name =  "amzn-ami-hvm-????.??.?.????????-x86_64-gp2"
          root-device-type = "ebs"
        }
        most_recent = true
        owners = ["amazon"]
    }
    launch_block_device_mappings {
        device_name = "/dev/xvda"
        volume_size = 20
        volume_type = "gp2"
        delete_on_termination = "true"
    }
    launch_block_device_mappings {
        device_name = "/dev/xvdf"
        volume_size = 500
        volume_type = "gp2"
        delete_on_termination = true
        encrypted = true
    }

    ami_regions = ["eu-central-1"]
    run_tags {
        Name = "packer-solr-something"
        stack-name = "DevOps Tools"
    }

    communicator = "ssh"
    ssh_pty = true
    ssh_username = "ec2-user"
    associate_public_ip_address = true
}

Novos binários podem ser encontrados aqui

Vou bloquear este problema porque ele está fechado há _30 dias_ ⏳. Isso ajuda nossos mantenedores a encontrar e focar nos problemas ativos.

Se você encontrou um problema semelhante a este, abra um novo problema e preencha o modelo de problema para que possamos capturar todos os detalhes necessários para uma investigação mais aprofundada.