News for hackers. Stuff that matters.
Re:Infrastructure as Code, Part One by royjacobs on Saturday April 13, 2019 @12:12PM (#19653843)
What I find unfortunate about infrastructure-as-code tooling is that a lot of the tooling isn't actually using code, but instead uses esoteric configuration languages. Indeed, the article refers to Terraform with its custom syntax.

Imho tools should use actual code (whether it's TypeScript or Kotlin or whatever) instead of reinventing constructs like loops and string interpolation.

Thankfully these tools are getting more popular, because frankly I can't stand configuring another Kubernetes or GCP resource using a huge block of copy/pasted YAML.

Re:Infrastructure as Code, Part One by scarface74 on Saturday April 13, 2019 @04:27PM (#19655520)
Wanting IAC to be procedural instead of declarative is like saying you want SQL to be procedural.

You’re not telling AWS how to do something you’re telling it what you want the end state to be and let it figure out what needs to be created, updated, deleted, or replaced and the dependency chain what can be run in parallel when you create or update the template.

There are linters and editors for CloudFormation that help you with autocomplete (?) and to warn you when you are specifying a a resource type. You can even add your own custom definitions to the linters for custom resource types that you create.

CloudFormation just like generic SQL doesn’t by itself have the concept of loops. CloudFormation does support custom transforms and macros that you can create in any language and you can write programs that generate CF in many languages using the CDK where it will perform validation. I haven’t used it so I am being really hand wavy.

Re:Infrastructure as Code, Part One by johncolanduoni on Saturday April 13, 2019 @04:46PM (#19655608)
I agree with this in general, but I think there’s room for more programmatic ways of calculating what the desired state is in tools like Terraform. There are already a lot of built-ins in terraform that are deterministic but procedural ways of calculating what the state is, without infecting the declarative nature of the reconciliation process.
Re:Infrastructure as Code, Part One by nicois on Saturday April 13, 2019 @05:45PM (#19655921)
We also were frustrated at the verboseness and vagaries of the terraform syntax.

We ended up preprocessing them using jinja2, injecting our variables via its context, and using its cleaner syntax for expressing conditions, loops, etc. Now we have the best of both worlds.

Re:Infrastructure as Code, Part One by pm90 on Saturday April 13, 2019 @06:38PM (#19656195)
... until your jinja templating breaks for some obscure reason, or the underlying terraform resource upgrades (they follow the provider api after all), or if you need to do some state surgery and partition one terraform state into multiple ones, or until you want to import resources into the generated terraform or....

Apologies, I don't mean to be a downer. But... you're making your present life easier but making the code harder to maintain for future maintainers of your codebase.

Re:Infrastructure as Code, Part One by detaro on Saturday April 13, 2019 @08:39PM (#19656755)
What's the more maintainable alternative? Is writing repeated constructs etc out individually really more maintainable, or are you referring to other ways of getting these things reduced?
Re:Infrastructure as Code, Part One by nitelord on Saturday April 13, 2019 @09:53PM (#19657054)
I highly recommend taking a look at the AWS CDK. It's a relatively new project, still in beta and hasn't gotten a lot of attention yet. It allows you to use real programming languages to generate Cloudformation templates. In my eyes this is the best of both worlds.
Re:Infrastructure as Code, Part One by pm90 on Saturday April 13, 2019 @09:39PM (#19656996)
Just plain terraform modules, for now.

I’m eagerly awaiting 0.12 so the language would have similar features as jinja templating.

Re:Infrastructure as Code, Part One by viraptor on Saturday April 13, 2019 @05:54PM (#19655970)
If that's what you want to achieve, you can generate the terraform files from any external system. Basically template it.

That's what sparkleformation does for cloudformation stacks.

Re:Infrastructure as Code, Part One by closeparen on Saturday April 13, 2019 @07:07PM (#19656343)
When there is live traffic or data in the infrastructure you’re modifying, the procedure matter a great deal.

Just as in databases, you end up playing lots of “read the query plan, restate the query to try and get a better one” games.

Re:Infrastructure as Code, Part One by lukehoban on Saturday April 13, 2019 @01:02PM (#19654235)
Here at Pulumi, this is something we are working hard on!

For all the many benefits we've seen with Infrastructure as Code to date, the tools are still fairly primitive - copy/paste is the norm for reuse, testing is rare or non-existant, productivity during infrastructure development is low, continuous integration and delivery are largely ad-hoc, and there are very few higher-level libraries available to abstract away the complex details of today's modern cloud platforms. Net - it feels like we're still programming cloud infrastructure at the assembly-language level.

I'm really excited about the opportunity to bring more software engineering rigor into the infrastructure as code space. At Pulumi we believe using existing programming languages is a key enabler of this. Pulumi is still a desired state model like other Infrastructure as Code offerings (so you can still preview changes and make minimal deltas to existing infrastructure) - but you can write code to construct that desired state. As a result, you get for loops and conditionals, you get types and error checking, you get IDE productivity tooling, you can create abstractions and interfaces around components, you can write tests, you can confidently refactor you infrastructure code, you can deliver and version components via robust package managers, and you can integrate naturally into CI/CD workflows.

Pulumi isn't the only tool in this space - we're seeing things like Atomist bringing this same model to delivery pipelines, and AWS CDK bringing this model to the CloudFormation space. I'm excited about where these tools will take the Infrastructure as Code ecosystem in the coming years.

[disclaimer - CTO at https://pulumi.io so clearly biased on this topic :-)]

Re:Infrastructure as Code, Part One by royjacobs on Saturday April 13, 2019 @05:55PM (#19655973)
Pulumi definitely looks very nice and I hope you manage to get some traction in the k8s space. The amount of stacked tooling (like skaffold) currently being used in that space is papering over the real issue that raw YAML simply isn't working.

So good luck to you!

Re:Infrastructure as Code, Part One by hedwall on Saturday April 13, 2019 @01:12PM (#19654321)
What I've seen is that when you get a real programming language for IaC you'll end up with a half assed, poorly implemented and documented version of a declarative DSL that is organization specific.

I saw it with early versions of Chef, I've seen it with Apache Auroras python based job specs for Mesos etc.

I'd rather work around the limitations of a DSL that is declarative and limited but is consistent across orgs than having to retrain myself if I move to a new job.

Re:Infrastructure as Code, Part One by linuxftw on Saturday April 13, 2019 @04:59PM (#19655688)
What's nice about ansible, if you can grok how the inventory system works, custom modules and plugins are super simple. So, OP could indeed program in the manner they wish, with a very nice/simple abstraction on top.
Re:Infrastructure as Code, Part One by aleph- on Saturday April 13, 2019 @05:04PM (#19655713)
Same for Salt Stack I'd say. Just a yaml wrapper around execution modules which themselves are either wrappers around cli's or pure python versions of them.
Re:Infrastructure as Code, Part One by argd678 on Saturday April 13, 2019 @01:40PM (#19654502)
I think this points more to that it’s a normal project that’s developed and you need competent developers like on any software project. The DSL route was likely to dumb things down for operations people with little software experience, but in doing so they created declarative models that don’t model reality and have created such an awkward fit that it reduces productivity that’s a solved problem for decades now.

Operations is the wrong place to do engineering, either that or operations needs to level up significantly since they do cause a lot of delays and damage to companies with these poorly design tools.

Re:Infrastructure as Code, Part One by joshuamorton on Saturday April 13, 2019 @02:51PM (#19654984)
using Turing complete languages for configs is a mistake.

Configs are hard, and they're different to enough from normal software (for example DRY doesn't apply in the same circumstances) that using the same tools is a bad idea.

I've seen what happens when swes use swe languages on configs. They get unintelligible. And then I have to clean up the messes.

To be clear though, using Json or toml for configs is also often a mistake.

Re:Infrastructure as Code, Part One by argd678 on Saturday April 13, 2019 @03:39PM (#19655291)
The problem is that the declarative model doesn’t fit, so in Terraform for example they’ve added branching and for loops even, so you’re making a language at that point. But rather than keeping the logic and the data structure separate, they’re mixed up with each other. This is a solved problem in many languages, Java especially.

I think a valid question would be what is the right framework factoring or design should be, but pure declarative isn’t not and half declarative like Terraform are just repeating past mistakes.

Re:Infrastructure as Code, Part One by TeMPOraL on Saturday April 13, 2019 @04:20PM (#19655497)
> for example DRY doesn't apply in the same circumstances

Doesn't it, though? Dumb configs tend to suffer very much because of the impossibility to apply DRY directly, and people end up using/writing config generators just to ensure consistency of values.

Hell, isn't half of the job of a IaC tool to be such a config generator, papering over lack of capabilities of configuration languages?

Re:Infrastructure as Code, Part One by joshuamorton on Saturday April 13, 2019 @07:00PM (#19656303)
>Doesn't it, though?

Theoretically, maybe. In practice, I don't think so. Mostly because code is much less prone to change than configs are. Like if you have some encapsulated set of behavior in code, it's often easy (and not particularly painful) to do something like

    self.thing = x if self.other else default
This is (normally) fine. Sometimes this will expand to be 2-3 different things. So you might get

    if self.other:
       self.val = ...
    elif self.different_situation:
       self.val = ...
    else:
       self.val = default
And this avoids setting self.val in all of the child classes, it's "nice and DRY".

Because code-code doesn't change that much, this kind of weird gross encapsulated behavior is (usually) ok. It's still a code-smell, but you don't get burned by it. But when you are dealing with configs, they do change, and you want to be extra explicit, because (as you probably know), the number of exceptions and special cases will inevitably grow, and you'll end up with implicit leaf-level configuration hidden away in your so-called encapsulated stuff, but without end-user visibility into what is actually happening.

One solution to this is to completely ignore DRY and ensure consistency via unit tests or static analyzers or something, but that also sucks (possibly more) than doing some denormalization within your config-language itself.

My experience says the right way to do this is to restrict yourself to not using any conditionals other than perhaps get-with-default, and doing everything that would be done conditionally via inheritance or composition. Remains to be seen if I think I made the right decision 5 years from now.

Re:Infrastructure as Code, Part One by argd678 on Saturday April 13, 2019 @08:41PM (#19656758)
These inheritance constructs are either missing or too ridged in the current tooling to be able to use those patterns unfortunately. Java in a lot of ways seems like an ideal language, especially with AOP, where for example you could use exactly the same code and swap out the cloud provider.
Re:Infrastructure as Code, Part One by joshuamorton on Saturday April 13, 2019 @10:02PM (#19657092)
I agree that most languages are bad for this. I think Java is also too verbose to be a good config language. My experience has been with a Python dsl but I'm open to other options too.
Re:Infrastructure as Code, Part One by argd678 on Sunday April 14, 2019 @12:23AM (#19657604)
I actually see it less as a configs language issue and more that you want a program that encapsulates the patterns and logic for your app to run. So the language itself is a bit less of an issue other than it needs to support the model you’re creating.
Re:Infrastructure as Code, Part One by scarface74 on Saturday April 13, 2019 @04:28PM (#19655529)
CF supports macros and custom transforms that can be written in any language.
Re:Infrastructure as Code, Part One by pm90 on Saturday April 13, 2019 @06:41PM (#19656209)
> The DSL route was likely to dumb things down for operations people with little software experience,

I find this a strange argument. Traditional operations people will still resist using these techniques, and will use pre-canned modules and resources if they're forced to use something.

The real reason seems to be because of the declarative nature of IaC rather than concerns about adoption.

Re:Infrastructure as Code, Part One by hedwall on Saturday April 13, 2019 @02:57PM (#19655020)
I'm trying to write something snappy, but honestly you're just rude. Your shitting on my profession and from here it looks like you've only ever operated extremely simple production environments.

(Those examples, the real world ones, where from competent software developers that did product development, not operations people).

Re:Infrastructure as Code, Part One by argd678 on Saturday April 13, 2019 @03:29PM (#19655229)
I’ve seen both at sizable scales, the logic patterns are the same, the complexity almost always comes from incorrect modeling of the problem (which devops tools perpetuate). Once a problem is solved correctly, take K8s for example, then the problem becomes much simpler and operations has a well thought out model to work in.

If you’re in technology your profession is to solve problems, it’s not to entrench poor decisions in a company, which in some sense everyone is at fault for, but this area affects a lot of a company and the attitudes are pretty anti-improvement if it goes out of someone’s skill set. The end result is that the software will be moved out of operations, I see this more and more. Operations can’t improve just by magic, they need to embrace the past 50 years of computing knowledge too.

Re:Infrastructure as Code, Part One by pm90 on Saturday April 13, 2019 @06:45PM (#19656225)
> Operations can’t improve just by magic, they need to embrace the past 50 years of computing knowledge too.

Oh. Really? /s

That's literally what DevOps is all about. I'm sorry but Infrastructure isn't as simple to manage in code as "regular" software. The Infrastructure API's mutate or behave in unexpected ways too often. State drift is common. There is active work in figuring out better solutions. But to say that operations have not embraced computing knowledge is nonsense.

Re:Infrastructure as Code, Part One by argd678 on Saturday April 13, 2019 @12:59PM (#19654209)
Agreed completely, the current state is like using a language with no debugger, no modern knowledge of code reuse, no real IDE integration, Terraform is especially poor on a large project since it’s parser doesn’t report line numbers on errors and it has no forward references or ways to resolve interdependence between objects and leaves that up to the user to manually converge its state, not to mention you have to rewrite everything for every cloud and it’s riddled with bugs for common uses.

Pulumi is going down a better route in that they’re using a normal programing language with a normal tool set, however I’m skeptical of how their engine is designed with RPC calls for language bindings, since again it makes debugging more complex as opposed to just a normal sdk. They also don’t have debugging enabled yet.

Re:Infrastructure as Code, Part One by adontz on Saturday April 13, 2019 @02:48PM (#19654957)
I do not think imperative languages are better, because they suck at parallelization. And creating infrastructure elements in parallel is crucial.

What I see as optimal is tool like make, which calls other command line tools. Resolves dependencies, processes errors. But not make, something with sane syntax and error handling.

All these new fancy all-Go tools creep me out. Infrastructure tooling should not live in domain of one programming language. Extensibility should be language agnostic. If I want to write some Perl/Python/Bash script to support some very non standard part of my infrastructure, I should be able to. If I want to plug vendor specific utility execution into deployment pipeline, I should be able to. And it should be easy.

Re:Infrastructure as Code, Part One by mdaniel on Saturday April 13, 2019 @05:48PM (#19655942)
> All these new fancy all-Go tools creep me out.

It certainly makes one's ability to look into the machinery and know what is going on much harder.

> If I want to write some Perl/Python/Bash script to support some very non standard part of my infrastructure, I should be able to

That very feature is why I love ansible: if there is some quirk, or even an unreleased module (they only ship new features in major releases, I recently learned), then you can copy the upstream file, or a modified version of the existing one, or even a whole new module, into the `library` or `lookup_plugins` directory of your playbook and you're back in business. No fighting with golang anything. You can also write ansible modules in any language you like.

Re:Infrastructure as Code, Part One by aphextron on Saturday April 13, 2019 @09:26PM (#19656949)
>Imho tools should use actual code (whether it's TypeScript or Kotlin or whatever) instead of reinventing constructs like loops and string interpolation.

The counterpoint to this is things like Gulp or Gradle which become a nightmare after a couple years of multiple developers and coding styles appending things here and there. Now rather than just spending a few hours learning a basic config DSL, I have to build up a mental execution model every time I want to add a build step.

Re:Infrastructure as Code, Part One by pknopf on Saturday April 13, 2019 @06:32PM (#19656168)
I don't mind using code to generate what the status should look like, as long as the code doesn't actually mutate the state.

Similar to React and it's virtual dom.

Re:Infrastructure as Code, Part One by novaleaf on Sunday April 14, 2019 @10:56AM (#19659760)
I've moved my bash based GCP vm deployment script to typescript, via shelljs: https://www.npmjs.com/package/shelljs

ShellJs works pretty nice. Not only is my script now cross platform, but doing conditional logic and user prompting is a lot easier in code than bash.

The only "issue" I've found is that ShellJs is quite barebones. I wrote a wrapper over it to do everything, such as nice question prompting and colored output.

Re:Infrastructure as Code, Part One by amq on Saturday April 13, 2019 @12:18PM (#19653880)
Could you name some of those code-based tools?
Re:Infrastructure as Code, Part One by ryanworl on Saturday April 13, 2019 @12:21PM (#19653900)
Re:Infrastructure as Code, Part One by rad_gruchalski on Sunday April 14, 2019 @09:04AM (#19659189)
One of the oldest examples of this: https://github.com/infochimps-labs/ironfan. But yeah, Chef. Examples: https://github.com/infochimps-labs/ironfan-pantry/blob/maste....

I used to use this heavily back in 2013, 2014. Infochimps got picked up by eBay, afair. Hence why this was never developed further.

Re:Infrastructure as Code, Part One by closeparen on Saturday April 13, 2019 @12:30PM (#19653957)
Start with hitting cloud provider APIs directly, then looking for value-add on top of that.
Re:Infrastructure as Code, Part One by cle on Saturday April 13, 2019 @12:57PM (#19654197)
Re:Infrastructure as Code, Part One by robbyt on Saturday April 13, 2019 @11:24PM (#19657409)
This was called Chef, and every time I've encountered a Chef infrastructure it's been a complete mess.
Re:Infrastructure as Code, Part One by nicodjimenez on Saturday April 13, 2019 @09:30PM (#19656963)
So true! Declarative tooling works great until you have a complex situation, and the abastraction leaks.
Re:Infrastructure as Code, Part One by rhizome on Saturday April 13, 2019 @10:35PM (#19657213)
The way I think of it is that there's too much personality in this technology.
Re:Infrastructure as Code, Part One by kissgyorgy on Saturday April 13, 2019 @05:58PM (#19655996)
> Imho tools should use actual code (whether it's TypeScript or Kotlin or whatever) instead of reinventing constructs like loops and string interpolation.

I disagree with this one. I believe describing an infrastructure should be fully declarative and the tool should decide how it needs to create resources based on the description. This way, the infrastructure code almost can't have bugs, but the tool can be fixed for everybody.