What do you think?
Rate this book
Terraform: Up and Running: Writing Infrastructure as Code
Terraform has emerged as a key player in the DevOps world for defining, launching, and managing infrastructure as code (IAC) across a variety of cloud and virtualization platforms, including AWS, Google Cloud, and Azure. This hands-on book is the fastest way to get up and running with Terraform. Gruntwork co-founder Yevgeniy (Jim) Brikman walks you through dozens of code examples that demonstrate how to use Terraform’s simple, declarative programming language to deploy and manage infrastructure with just a few commands. Whether you’re a novice developer, aspiring DevOps engineer, or veteran sysadmin, this book will take you from Terraform basics to running a full tech stack capable of supporting a massive amount of traffic and a large team of developers.
329 pages, Kindle Edition
Published March 13, 2017
631 people are currently reading
1,231 people want to read
About the author
Yevgeniy Brikman
6books715followersYevgeniy (Jim) Brikman is the co-founder of , a company that that offers products & services for setting up world-class DevOps Foundations. He's also the author of three books published by O'Reilly:
,
, and
. Previously, he worked as a software engineer at LinkedIn, TripAdvisor, Cisco Systems, and Thomson Financial and got his BS and Masters at Cornell University. For more info, check out .
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 30 of 93 reviews
May 30, 2018
It's one of the most prospering books written about Terraform. Although it's based on Terraform version 0.8, and a lot of things has changed since then, still the examples in the book hold the truth. Moreover, are also updated day by day, they force the correct version of terraform to be used.
The author describes why and how should one use Terraform, the importance of the Infrastructure as Code in the first chapter. And step by step, chapter by chapter, the author gives the most of best practices of terraform, how to organize your infrastructure code and main problems you may encounter. The chapters explaining terraform are heavily on AWS, some may consider that a thumbsdown for the book, but as the author explained the reason for that, all those examples can be tested on a free tier AWS account, unless it is stated otherwise.
I really enjoyed the whole read. Apart from Appendix A, Recommended Reading section, which includes quite good resources too, the conclusion part of each chapter summarizes the aspects mentioned in that chapter, and explains the related footnotes in the chapter. Some of those footnotes were eminently interesting, some of them I already knew.
Some of the references to mention here:
Also some bugs mentioned in the book:
Solved ones:
*
About Zero Downtime deployment
*
Related to Eventual consistency
*
*
*
Still open:
*
I've been using Terraform for almost two years right now, and I'd recommend this book to anyone who wants to increase their understanding on terraform and its best practices. What I would expect from the author to update in the next version of this book:
1) Update the code to work with the current version of Terraform. Providers are now separated from the main repository and the way terraform init works has changed slightly.
2) About testing the terraform infrastructure, they already mentioned and , although it's pretty new, definitely needs a mention here. As It's already been developed by the author's company, I believe it would take place in the next edition/version of the book.
The author describes why and how should one use Terraform, the importance of the Infrastructure as Code in the first chapter. And step by step, chapter by chapter, the author gives the most of best practices of terraform, how to organize your infrastructure code and main problems you may encounter. The chapters explaining terraform are heavily on AWS, some may consider that a thumbsdown for the book, but as the author explained the reason for that, all those examples can be tested on a free tier AWS account, unless it is stated otherwise.
I really enjoyed the whole read. Apart from Appendix A, Recommended Reading section, which includes quite good resources too, the conclusion part of each chapter summarizes the aspects mentioned in that chapter, and explains the related footnotes in the chapter. Some of those footnotes were eminently interesting, some of them I already knew.
Some of the references to mention here:
Also some bugs mentioned in the book:
Solved ones:
*
About Zero Downtime deployment
*
Related to Eventual consistency
*
*
*
Still open:
*
I've been using Terraform for almost two years right now, and I'd recommend this book to anyone who wants to increase their understanding on terraform and its best practices. What I would expect from the author to update in the next version of this book:
1) Update the code to work with the current version of Terraform. Providers are now separated from the main repository and the way terraform init works has changed slightly.
2) About testing the terraform infrastructure, they already mentioned and , although it's pretty new, definitely needs a mention here. As It's already been developed by the author's company, I believe it would take place in the next edition/version of the book.
November 28, 2020
Really, between 4 & 5...
very good introduction into terraform, showing how to solve problems with it, and most important - how to productionalize its use.
very good introduction into terraform, showing how to solve problems with it, and most important - how to productionalize its use.
Read
June 19, 2018Mixed feelings: Good book, great content which puts you into the mindset of DevOps with Terraform. I used the tool then got "back to the library to get some theory" and then went fresh and happy to apply my learning.
This is where a negative surprise hit: book is based on an older version of the tool so the content which I tried to use ("terraform remote" specifically) is deprecated which means that I now have to re-learn all that stuff...
I could not find good erratta nor the Github repository of the book has updated the sample code or chapters... Bummer.
This is where a negative surprise hit: book is based on an older version of the tool so the content which I tried to use ("terraform remote" specifically) is deprecated which means that I now have to re-learn all that stuff...
I could not find good erratta nor the Github repository of the book has updated the sample code or chapters... Bummer.
December 24, 2018
An excellent introduction to Infrastructure As Code (IAC) using Terraform. As it happens with most of the tech books for modern technology which is highly under development, this book covers a dated version of terraform. However, I still highly recommend this book because more than the code, this book also talks about approaches towards IAC and the pitfalls one can see when developing and maintaining IAC in a environment with larger teams.
Contrary to popular belief the readers will be surprised to know that writing IAC using terraform does not mean that changing the provider will result in exactly the same infrastructure under a different provider as each provider has a different set of services and a different way to provide those services.
The examples in this book covers only AWS as a provider.
Contrary to popular belief the readers will be surprised to know that writing IAC using terraform does not mean that changing the provider will result in exactly the same infrastructure under a different provider as each provider has a different set of services and a different way to provide those services.
The examples in this book covers only AWS as a provider.
July 3, 2020
I've been a big fan of Yevgeniy ever since I read his Terraform series on Medium. One of the most important things often missing from tutorials are what is the problem and why should people use this to solve it. Yevgeniy always addresses the why first and foremost.
This book is an excellent introduction to why companies need to incorporate DevOps, why use infrastructure as code, and specifically why use Terraform. He walks you through the best practices of project structure, testing, collaboration, third-party tools, CI/CD, and more. Yevgeniy is clearly an expert and shares many of the nuances and gotchas that only come with experience.
I honestly think this is the best resource on Terraform, and should be mandatory reading for anyone needing to quickly get up to speed.
The only negative was reading large blocks of code spanning multiple pages was a little difficult at times, but maybe that's just a limitation of the medium.
This book is an excellent introduction to why companies need to incorporate DevOps, why use infrastructure as code, and specifically why use Terraform. He walks you through the best practices of project structure, testing, collaboration, third-party tools, CI/CD, and more. Yevgeniy is clearly an expert and shares many of the nuances and gotchas that only come with experience.
I honestly think this is the best resource on Terraform, and should be mandatory reading for anyone needing to quickly get up to speed.
The only negative was reading large blocks of code spanning multiple pages was a little difficult at times, but maybe that's just a limitation of the medium.
September 23, 2024
Excellent introduction to Terraform, with plenty of information on best practices. I’d kill for Terraform as well managed as he describes in this book. It’s aspirational and a great guide wherever you are on your iac journey
August 10, 2022
Incredible first chapter. It cleared a lot of confusion for me regarding how different tools are used together.
February 20, 2022
I usually write a review only some time after I finish reading. At first, I rated it only four stars - just a really solid book about Terraform I thought. When I started writing this review, I tried to find some weaknesses in order to explain it. And you know what? I couldn't find anything. So I change my rate! Five stars here.
What I liked:
- This book helped me understanding how Terraform works and what are the strengths / weaknnesses (immutable, declarative, agentless and so on)
- Practical examples with AWS provider.
- Comparison of Terraform versus other IaC tools.
- First chapters were high-quality (but still) tutorial for using the Terraform. There was a lot of content but I didn't feel completely satisfied (maybe this is the reason behind my initial lower rate...). However, the second half of the book has filled "the vessel with water". Great chapters about testing and using Terraform as a team (love the checklist and workflow of deployment).
- Many tips and good software engineering practices scattered throughout the book (small modules, DI, composability, testability etc.). I appreciate that author tried no to stick solely to the teaching of Terraform API and Terraform tricks. It's rather a full-fledged help how to use Terraform as a IaC tool in enterprise production enviromnent.
I recommend!
What I liked:
- This book helped me understanding how Terraform works and what are the strengths / weaknnesses (immutable, declarative, agentless and so on)
- Practical examples with AWS provider.
- Comparison of Terraform versus other IaC tools.
- First chapters were high-quality (but still) tutorial for using the Terraform. There was a lot of content but I didn't feel completely satisfied (maybe this is the reason behind my initial lower rate...). However, the second half of the book has filled "the vessel with water". Great chapters about testing and using Terraform as a team (love the checklist and workflow of deployment).
- Many tips and good software engineering practices scattered throughout the book (small modules, DI, composability, testability etc.). I appreciate that author tried no to stick solely to the teaching of Terraform API and Terraform tricks. It's rather a full-fledged help how to use Terraform as a IaC tool in enterprise production enviromnent.
I recommend!
July 20, 2018
My first ever O'Reilly book, surprisingly. Already had some familiarity with Terraform but the book introduced me to some new concepts like shared state in S3 and the advantage of specialized modules for maximum abstraction of infrastructure, which I'm excited to try out in some of my own applications.
Only problem is that Terraform moves so fast that some of the information is outdated (e.g. remote state backend setup has slightly different syntax and semantics now), but I don't blame the author because some of Terraform's online docs are outdated too and sometimes you just have to search GitHub issues for a solution.
Regardless, a comprehensive and well-written guide that covers the main points of Terraform and infrastructure-as-code well. The author briefly covers the pros and cons of other solutions like Puppet, Chef, Ansible, and Docker, too, so I would recommend to anyone looking to learn about best practices for application infrastructure and devops.
Only problem is that Terraform moves so fast that some of the information is outdated (e.g. remote state backend setup has slightly different syntax and semantics now), but I don't blame the author because some of Terraform's online docs are outdated too and sometimes you just have to search GitHub issues for a solution.
Regardless, a comprehensive and well-written guide that covers the main points of Terraform and infrastructure-as-code well. The author briefly covers the pros and cons of other solutions like Puppet, Chef, Ansible, and Docker, too, so I would recommend to anyone looking to learn about best practices for application infrastructure and devops.
June 28, 2018
Having been working with Terrafrom for a while, a lot of the information in the book was not that informative, but I did pick up a couple of useful tips. I think for a complete beginner this could be very useful, as it is well written , and if you follow the examples a good way to get into the code. Obviously as with all tech books this has aged, and the Terraform code has moved on considerably since it was published. So watch out for things that might have been a problem when the book was written , but aren't now.
I can happily recommend this book for people getting started in the Topic, but if you have a lot of field experience already, you might just want to cherry pick the chapters you read.
I can happily recommend this book for people getting started in the Topic, but if you have a lot of field experience already, you might just want to cherry pick the chapters you read.
June 1, 2017
This book is a very important introduction to Terraform and allow me to quickly build "plans" to automate the deployment of stacks to AWS and MS Azure Cloud infrastructures, following best practices. Here you will find good recommendations on how to use Terraform as a team, how organize your Terraform scripts in version control system, orchestrate the deployment and integrate testing before applying your changes in Production. I liked how the content has been structured the examples. I recommend this book
August 1, 2020
Very good introduction to concepts of IaC then basics and advanced Terraform aspects. Currently only book worth reading on that topic. Lots of coffee samples with explanation, tests in Go. The only minus for me is that all examples are with AWS, would like to see code for different cloud providers, at least one chapter.
December 27, 2023
This book is my first proper step into Infrastructure as Code (IaC) and Terraform, and I would highly recommend it as an introduction to both subjects. It has quickly taken me from being bewildered by the existing Terraform code written by my colleagues, to writing my own production-grade Terraform.
The book is written in a tutorial style, where you build a Terraform project to create infrastructure on AWS. It starts simple, but the complexity gradually ramps up as new infrastructure is added and new concepts are introduced to solve realistic problems.
The book uses AWS for almost all the examples, and uses Go during the chapter on testing. I had some experience with AWS and no experience with Go before reading this, but I had no trouble following along.
Chapter 1 covers the general concepts of DevOps and IaC, situating Terraform in the broader IaC landscape (as a provisioning tool vs., for example, Ansible, a configuration management tool).
Chapter 2 introduces the basic concepts of Terraform (providers, resources, data sources, input variables, output variables), with some relatively simple infrastructure deployed to AWS.
Chapter 3 explains how Terraform keeps track of your infrastructure using state, and how you can store it remotely in S3. State is a pretty important concept in Terraform so it's worthy of its own chapter.
Chapter 4 shows how to create reusable Terraform modules, which reduce the need for duplication across environments and projects (analogous to reusable libraries in general purpose programming languages). These modules can either be reused locally in one project or sourced from a Git repo URL.
Chapter 5 covers some more advanced Terraform features, like loops and conditionals, some general gotchas, and a way to configure zero-downtime deployments with EC2 autoscaling groups.
Chapter 6 demonstrates the different ways of handling various kinds of secrets with Terraform. For example, you can store a secret in AWS Secrets Manager and retrieve it with a Terraform data source. One important thing to note is that any secret passed into Terraform resources or data sources will be stored in plaintext in the state file, which is why it's so important to have a state backend with encryption and access control.
Chapter 7 dives deeper into providers (the plugins that allow Terraform to work with external services like AWS). This chapter shows how to use multiple providers in order to work with multiple AWS regions and accounts, or multiple different services (in this case, the AWS and Kubernetes providers are used together).
Chapter 8 takes a step back and discusses how to make Terraform ready for production. A production-ready checklist is provided, which covers everything you might need to think about before your application is ready for production. The bulk of the chapter is about the characteristics of good reusable modules: small, composable, testable, and versioned.
Chapter 9 is about testing. The essence of testing Terraform is: apply, validate, destroy. In the example, we deploy a load balancer, make a request and check that we get the expected response, then destroy the infrastructure. A Go library called Terratest is used to do all this. The author tries to make a distinction between unit, integration and end-to-end tests, but these are all integration tests as they all test how your code works with an external service (AWS). The only difference is how many Terraform modules you are deploying. Some other testing methods, like static analysis, are also mentioned.
Chapter 10 gives some pointers on how to convince your team/company to adopt Terraform and how it can fit into your continuous delivery workflow. This is the first time Terragrunt is used, to show how it can reduce duplication of Terraform code between environments (the author is a co-founder of Gruntwork, the company which develops Terragrunt. It's probably also worth mentioning that Gruntwork appears to be a major supporter of OpenTofu, the open source fork of Terraform which came about due to the recent Terraform licence change, but this all happened after the book was published).
The appendix also has some great recommended resources for further learning.
The book is written in a tutorial style, where you build a Terraform project to create infrastructure on AWS. It starts simple, but the complexity gradually ramps up as new infrastructure is added and new concepts are introduced to solve realistic problems.
The book uses AWS for almost all the examples, and uses Go during the chapter on testing. I had some experience with AWS and no experience with Go before reading this, but I had no trouble following along.
Chapter 1 covers the general concepts of DevOps and IaC, situating Terraform in the broader IaC landscape (as a provisioning tool vs., for example, Ansible, a configuration management tool).
Chapter 2 introduces the basic concepts of Terraform (providers, resources, data sources, input variables, output variables), with some relatively simple infrastructure deployed to AWS.
Chapter 3 explains how Terraform keeps track of your infrastructure using state, and how you can store it remotely in S3. State is a pretty important concept in Terraform so it's worthy of its own chapter.
Chapter 4 shows how to create reusable Terraform modules, which reduce the need for duplication across environments and projects (analogous to reusable libraries in general purpose programming languages). These modules can either be reused locally in one project or sourced from a Git repo URL.
Chapter 5 covers some more advanced Terraform features, like loops and conditionals, some general gotchas, and a way to configure zero-downtime deployments with EC2 autoscaling groups.
Chapter 6 demonstrates the different ways of handling various kinds of secrets with Terraform. For example, you can store a secret in AWS Secrets Manager and retrieve it with a Terraform data source. One important thing to note is that any secret passed into Terraform resources or data sources will be stored in plaintext in the state file, which is why it's so important to have a state backend with encryption and access control.
Chapter 7 dives deeper into providers (the plugins that allow Terraform to work with external services like AWS). This chapter shows how to use multiple providers in order to work with multiple AWS regions and accounts, or multiple different services (in this case, the AWS and Kubernetes providers are used together).
Chapter 8 takes a step back and discusses how to make Terraform ready for production. A production-ready checklist is provided, which covers everything you might need to think about before your application is ready for production. The bulk of the chapter is about the characteristics of good reusable modules: small, composable, testable, and versioned.
Chapter 9 is about testing. The essence of testing Terraform is: apply, validate, destroy. In the example, we deploy a load balancer, make a request and check that we get the expected response, then destroy the infrastructure. A Go library called Terratest is used to do all this. The author tries to make a distinction between unit, integration and end-to-end tests, but these are all integration tests as they all test how your code works with an external service (AWS). The only difference is how many Terraform modules you are deploying. Some other testing methods, like static analysis, are also mentioned.
Chapter 10 gives some pointers on how to convince your team/company to adopt Terraform and how it can fit into your continuous delivery workflow. This is the first time Terragrunt is used, to show how it can reduce duplication of Terraform code between environments (the author is a co-founder of Gruntwork, the company which develops Terragrunt. It's probably also worth mentioning that Gruntwork appears to be a major supporter of OpenTofu, the open source fork of Terraform which came about due to the recent Terraform licence change, but this all happened after the book was published).
The appendix also has some great recommended resources for further learning.
February 14, 2018
Terraform Up and Running is a great introduction and guide to becoming "able" with terraform to server provision with AWS.
Things to note beforehand:
* this book focuses on terraform only,
* AWS is the provider of choice and you'll see a lot of AWS lingo which is also explained. Familiarity is a plus, but not required,
* this is not a book that'll teach you devops best practices which is a plus in terms of book length.
So as you expect, the focus on the book is working with the AWS Terraform provider.
If you want an other provider, you'll have to manage yourself and probably won't benefit **that much** from the book.
It's highly recommended that you follow the AWS route.
There's also an open-source effort at to port for GCP and Azure (at the time of writing this).
Prepare your wallet if you want to follow every code example and actually raise environments. I highly recommend going for this, cause otherwise you won't get all the small gotchas of Terraform and most importantly - the current improvements in Terraform (at time of writing the review - TF is 0.11.3, but the book is written for TF 0.8-0.9). If you're "fast" as in not letting an instance run for a day, you'll get by the end of the book with less than $10 if you host in Frankfurt based on my fare. Afaik Ireland is even cheaper compared to Frankfurt.
Does the fact that the book is written for TF 0.8-0.9 hinder it from being useful now? Not at all.
I might say it's a big benefit. The author of the book is one of the authors of `terragrunt` which is a wrapper around terraform that enhances it with "state file locking" among many other things.
State file locking is extremely vital in making terraform work for teams of more than one person.
The book does a very, very solid job of teaching you how to use terraform right and not mess with your state. However there is another approach presented on how to prevent state file concurrency issues by using a CI to apply server provisioning. Of course this is limited to good will and sanity of other team members still not running terraform apply by themselves since I am not aware of an option preventing terraform users of running apply at all.
Since the book is written with terragrunt in mind, in TF 0.11 (and little prior to that), the new backend functionality that provides state locking for AWS s3 is already rolled out, which means that terragrunt is optional now. Your choice whether you want to use terragrunt.
But moving aside from small differences the book is very solid in regards of presenting you practical problems of creating and provisioning environments. Although for "content digestibility", they're greatly simplified compared to real staging/production and etc environments, they present the actual problems of how to use terraform at first, from syntax, declarative resources approach, using data/output/resource/var/module, procedural-like constructs, workflow and reusability.
There's also a focus on best practices. It's a big plus being nudged in the direction and learning not to use inline blocks for example, among other things.
So where does the book stand?
As in other devops books that work with an infrastructure as code, server templating and other tools - it's very important to have your examples always up-to-date and runnable. Unfortunately you'll run into missing AWS AMIs that you can't just find. Only solution is to understand the point that is being presented and provide your own AMIs that fill the MVP requirements of the service that must be deployed.
This will negatively affect the time needed to digest the content. This is my only downside with the book, hence the 4/5.
Things to note beforehand:
* this book focuses on terraform only,
* AWS is the provider of choice and you'll see a lot of AWS lingo which is also explained. Familiarity is a plus, but not required,
* this is not a book that'll teach you devops best practices which is a plus in terms of book length.
So as you expect, the focus on the book is working with the AWS Terraform provider.
If you want an other provider, you'll have to manage yourself and probably won't benefit **that much** from the book.
It's highly recommended that you follow the AWS route.
There's also an open-source effort at to port for GCP and Azure (at the time of writing this).
Prepare your wallet if you want to follow every code example and actually raise environments. I highly recommend going for this, cause otherwise you won't get all the small gotchas of Terraform and most importantly - the current improvements in Terraform (at time of writing the review - TF is 0.11.3, but the book is written for TF 0.8-0.9). If you're "fast" as in not letting an instance run for a day, you'll get by the end of the book with less than $10 if you host in Frankfurt based on my fare. Afaik Ireland is even cheaper compared to Frankfurt.
Does the fact that the book is written for TF 0.8-0.9 hinder it from being useful now? Not at all.
I might say it's a big benefit. The author of the book is one of the authors of `terragrunt` which is a wrapper around terraform that enhances it with "state file locking" among many other things.
State file locking is extremely vital in making terraform work for teams of more than one person.
The book does a very, very solid job of teaching you how to use terraform right and not mess with your state. However there is another approach presented on how to prevent state file concurrency issues by using a CI to apply server provisioning. Of course this is limited to good will and sanity of other team members still not running terraform apply by themselves since I am not aware of an option preventing terraform users of running apply at all.
Since the book is written with terragrunt in mind, in TF 0.11 (and little prior to that), the new backend functionality that provides state locking for AWS s3 is already rolled out, which means that terragrunt is optional now. Your choice whether you want to use terragrunt.
But moving aside from small differences the book is very solid in regards of presenting you practical problems of creating and provisioning environments. Although for "content digestibility", they're greatly simplified compared to real staging/production and etc environments, they present the actual problems of how to use terraform at first, from syntax, declarative resources approach, using data/output/resource/var/module, procedural-like constructs, workflow and reusability.
There's also a focus on best practices. It's a big plus being nudged in the direction and learning not to use inline blocks for example, among other things.
So where does the book stand?
As in other devops books that work with an infrastructure as code, server templating and other tools - it's very important to have your examples always up-to-date and runnable. Unfortunately you'll run into missing AWS AMIs that you can't just find. Only solution is to understand the point that is being presented and provide your own AMIs that fill the MVP requirements of the service that must be deployed.
This will negatively affect the time needed to digest the content. This is my only downside with the book, hence the 4/5.
November 17, 2021
Currently, this is the best introduction into Terraform that is on the market. It isn't perfect, but this book does a really good job at taking someone who has never installed Terraform or used it and getting them up to what I would call "intermediate" level of knowledge. I actually interviewed for several DevOps jobs that required Terraform experience by solely reading this book and following along with the tutorials. It covers all the main Terraform concepts and I was able to even impress my interviewers based off the knowledge from this book.
The positives of the book would be that it covers all the main concepts of Terraform in a very easy-to-read way. Chapter 1 is a solid introduction to Terraform, its purpose, and its history. In chapters 2-5 you will actually follow a general infrastructure buildout from the first line of code, all the way through several refactors. Each refactor adding new features or better structure to the system. Essentially the author introduces a new concept and then shows how to improve our Terraform project by implementing that concept. I think this is a very good teaching method for beginners. The core features of Terraform are explained well and require no previous experience.
The negatives that I would identify would be that it is very front-heavy. Chapters 1-5 are pure gold. Chapter 6 is decent, and the last two chapters (7-8) are a mess. As others have pointed out, this book uses an older version of Terraform and several breaking changes have occurred. But I was still able to follow along. I assume the author will release a 3rd edition soon which should implement the new version 1 of Terraform which should be more stable going forward.
I also want to warn readers that the infrastructure in this book is not even close to production-quality. I think it is fine, since this is a book about Terraform and not Cloud Architecture, but it is worth noting. I wish the author had put a little more effort into delineating that. The examples in the book all use the AWS default VPC. Many features of load balancers, networking, and HA are omitted. I think it is ok, since the book is focused on Terraform itself and not the actual systems you are building. But it could give naive readers a false sense of empowerment to go out and deploy this system used in the book.
I was extremely interested in the final chapters about production-quality Terraform, using Terraform in a team, and automated testing with Terraform. Unfortunately these are the weakest chapters. Chapters 6 (Production Grade Terraform) is not very focused, but it does have some nuggets. Chapter 7 about testing terraform is a disaster. It did point me to a Terraform testing library which I will have to simply study elsewhere. Chapter 8 about Terraform as a team could basically be summed up as "use lock files, and source control/git".
This book really starts off as a masterpiece. Unfortunately it fails to stick the landing. However, with all that being said, this is still the book I give every new team member that needs to learn Terraform. Terraform is new and this is the most comprehensive guide that exists. I usually tell them they only need to read the first 5 chapters.
The positives of the book would be that it covers all the main concepts of Terraform in a very easy-to-read way. Chapter 1 is a solid introduction to Terraform, its purpose, and its history. In chapters 2-5 you will actually follow a general infrastructure buildout from the first line of code, all the way through several refactors. Each refactor adding new features or better structure to the system. Essentially the author introduces a new concept and then shows how to improve our Terraform project by implementing that concept. I think this is a very good teaching method for beginners. The core features of Terraform are explained well and require no previous experience.
The negatives that I would identify would be that it is very front-heavy. Chapters 1-5 are pure gold. Chapter 6 is decent, and the last two chapters (7-8) are a mess. As others have pointed out, this book uses an older version of Terraform and several breaking changes have occurred. But I was still able to follow along. I assume the author will release a 3rd edition soon which should implement the new version 1 of Terraform which should be more stable going forward.
I also want to warn readers that the infrastructure in this book is not even close to production-quality. I think it is fine, since this is a book about Terraform and not Cloud Architecture, but it is worth noting. I wish the author had put a little more effort into delineating that. The examples in the book all use the AWS default VPC. Many features of load balancers, networking, and HA are omitted. I think it is ok, since the book is focused on Terraform itself and not the actual systems you are building. But it could give naive readers a false sense of empowerment to go out and deploy this system used in the book.
I was extremely interested in the final chapters about production-quality Terraform, using Terraform in a team, and automated testing with Terraform. Unfortunately these are the weakest chapters. Chapters 6 (Production Grade Terraform) is not very focused, but it does have some nuggets. Chapter 7 about testing terraform is a disaster. It did point me to a Terraform testing library which I will have to simply study elsewhere. Chapter 8 about Terraform as a team could basically be summed up as "use lock files, and source control/git".
This book really starts off as a masterpiece. Unfortunately it fails to stick the landing. However, with all that being said, this is still the book I give every new team member that needs to learn Terraform. Terraform is new and this is the most comprehensive guide that exists. I usually tell them they only need to read the first 5 chapters.
October 22, 2022
It's a pretty good book to get you started with Terraform. It provides great best practices for using Terraform in your company you couldn't find in one place anywhere else.
Even though you can find most of the information online in docs or online articles, in the book such information is well structured and complicated topics are brought one by one without overwhelming the reader with complexity. This book is more than enough to help you set up Terraform in your projects on a decent level and start using it in production.
I would've rated this book 5 out of 5, but there is something that made it harder for me to read and even finish. Information is conveyed in a way of a tutorial... I couldn't stop thinking that I'm watching some YouTube video where the author sets everything up from scratch and explains why and how they did it. I agree that it has its own pros and cons. One of the significant advantages of this approach is that readers are not required to have almost any knowledge of AWS/Docker/Kubernetes/etc. Everything will be explained to some extent during each chapter to make sure that you can follow along... At the same time if you read this book to learn Terraform only and you already familiar with other technologies I mentioned before, you would have to skip a lot of pages to get to the actual new information. This makes the "fear of missing out" kick in and you cannot always be sure that you haven't missed something important. I believe if you get rid of all extra stuff and focus only on terraform, the book would be twice smaller and more actionable.
Anyways, I found this book useful for my day to day tasks with terraform. I just wish it was more to the point.
Even though you can find most of the information online in docs or online articles, in the book such information is well structured and complicated topics are brought one by one without overwhelming the reader with complexity. This book is more than enough to help you set up Terraform in your projects on a decent level and start using it in production.
I would've rated this book 5 out of 5, but there is something that made it harder for me to read and even finish. Information is conveyed in a way of a tutorial... I couldn't stop thinking that I'm watching some YouTube video where the author sets everything up from scratch and explains why and how they did it. I agree that it has its own pros and cons. One of the significant advantages of this approach is that readers are not required to have almost any knowledge of AWS/Docker/Kubernetes/etc. Everything will be explained to some extent during each chapter to make sure that you can follow along... At the same time if you read this book to learn Terraform only and you already familiar with other technologies I mentioned before, you would have to skip a lot of pages to get to the actual new information. This makes the "fear of missing out" kick in and you cannot always be sure that you haven't missed something important. I believe if you get rid of all extra stuff and focus only on terraform, the book would be twice smaller and more actionable.
Anyways, I found this book useful for my day to day tasks with terraform. I just wish it was more to the point.
September 29, 2023
Yevgeniy Brikman's "Terraform: Up and Running" is a stellar guide to one of the most game-changing tools in the DevOps landscape. The book, deserving of its 5 stars, delves deep into practical examples and offers invaluable tips for creating production-grade code. This ensures that readers not only understand the theory behind Terraform but can also implement best practices with confidence.
The rapid evolution of the DevOps industry, though still in its infancy, poses an interesting question. The myriad of tools associated with Terraform has set a precedent, and one can only wonder where the trajectory will take us. Given the ever-evolving nature of technology, this book presents an effective foundation for those wanting to stay ahead of the curve.
The emergence of OpenTofu, spearheaded by the Linux Foundation, as an open-source alternative to Terraform, is a testament to the need for flexibility and adaptability in the industry. Personally, I find the creation of this fork a refreshing move, reflecting the community's resilience and adaptability. HashiCorp's recent decisions around Terraform's licensing have been, in my opinion, questionable. Their approach might not have been in the best interest of the broader community. I'm optimistic that the OpenTofu initiative will keep the spirit of open-source and collaboration alive, ensuring the tool's longevity and relevance.
In conclusion, "Terraform: Up and Running" provides a comprehensive guide in these dynamic times. It equips readers with the knowledge and insights needed to navigate the ever-changing DevOps ecosystem while also hinting at the importance of community-driven adaptations.
The rapid evolution of the DevOps industry, though still in its infancy, poses an interesting question. The myriad of tools associated with Terraform has set a precedent, and one can only wonder where the trajectory will take us. Given the ever-evolving nature of technology, this book presents an effective foundation for those wanting to stay ahead of the curve.
The emergence of OpenTofu, spearheaded by the Linux Foundation, as an open-source alternative to Terraform, is a testament to the need for flexibility and adaptability in the industry. Personally, I find the creation of this fork a refreshing move, reflecting the community's resilience and adaptability. HashiCorp's recent decisions around Terraform's licensing have been, in my opinion, questionable. Their approach might not have been in the best interest of the broader community. I'm optimistic that the OpenTofu initiative will keep the spirit of open-source and collaboration alive, ensuring the tool's longevity and relevance.
In conclusion, "Terraform: Up and Running" provides a comprehensive guide in these dynamic times. It equips readers with the knowledge and insights needed to navigate the ever-changing DevOps ecosystem while also hinting at the importance of community-driven adaptations.
August 23, 2020
I read the first edition of this book, so the terraform version is a little dated, making the exercises hard to follow at times. Also goes to show how fast terraform is evolving and not even yet hit the first leading major version, I.e., 0.* version only. The other challenge was also the intro of terragrunt, by the author, which made an entry and then disappeared later on, making it hard to follow the tutorial style text.
As someone coming from a dev background, IaC comes fairly naturally and all the practice seems logical. I imagine codifying “hardware� setup and configuration also should be natural to infra people, maybe even more so, as I think, for operations, there is even more incentive to keep things neat and tidy so that workloads are always up and running.
On hindsight, without the proliferation of cloud, it would hard to see IaC taking hold as the languages would be so fragmented across each infra built out.
Anyway, I digress but my point is IaC is quite natural and terraform does this declaratively. And like most declarative situations, there are tactical know how to deal with imperative needs and the lack of if/then conditional in the language also requires some workaround.
The fact that IaC goes to “production� straightaway, so automation testing (which is a benefit of changing infra setup steps to code) also had to be dealt with in special cases. This part was dealt with in a fairly short section and leaves the imagination for the readers.
As someone coming from a dev background, IaC comes fairly naturally and all the practice seems logical. I imagine codifying “hardware� setup and configuration also should be natural to infra people, maybe even more so, as I think, for operations, there is even more incentive to keep things neat and tidy so that workloads are always up and running.
On hindsight, without the proliferation of cloud, it would hard to see IaC taking hold as the languages would be so fragmented across each infra built out.
Anyway, I digress but my point is IaC is quite natural and terraform does this declaratively. And like most declarative situations, there are tactical know how to deal with imperative needs and the lack of if/then conditional in the language also requires some workaround.
The fact that IaC goes to “production� straightaway, so automation testing (which is a benefit of changing infra setup steps to code) also had to be dealt with in special cases. This part was dealt with in a fairly short section and leaves the imagination for the readers.
December 26, 2019
This book was my first introduction to Terraform and I found it immensely helpful.
The code examples on Github are very clear, I found myself lost just following along in the book. I highly recommend that readers use the code examples while working through the book.
Good:
- Well written - Brikman is clearly an experienced writer and this practice shows. The book is enjoyable to read while presenting dense technical content.
- Well structured - We start with a “Hello World� example to get the reader up and running, then move onto more complex topics (shared state management, testing, modularization). The book finishes with a discussion of the very important subject of people management with Terraform - how do we introduce Terraform to a team and convince management to adopt this new technology?
- Inclusion of lots of recommended reading for the interested to extend their knowledge.
Suggestion for improvement:
- AWS examples only. Minor nit here, but it’s kind of a bummer that the examples in the book and on github are aws only. I can’t blame the author here, since the point is Terraform, not your favorite provider X.
- Inclusion of problems. I’d love to have an “Extra for Experts� of challenges for readers to solve to solidify their knowledge.
Overall:
A well written guide through Terraform and it’s associated best practices! Highly recommend.
The code examples on Github are very clear, I found myself lost just following along in the book. I highly recommend that readers use the code examples while working through the book.
Good:
- Well written - Brikman is clearly an experienced writer and this practice shows. The book is enjoyable to read while presenting dense technical content.
- Well structured - We start with a “Hello World� example to get the reader up and running, then move onto more complex topics (shared state management, testing, modularization). The book finishes with a discussion of the very important subject of people management with Terraform - how do we introduce Terraform to a team and convince management to adopt this new technology?
- Inclusion of lots of recommended reading for the interested to extend their knowledge.
Suggestion for improvement:
- AWS examples only. Minor nit here, but it’s kind of a bummer that the examples in the book and on github are aws only. I can’t blame the author here, since the point is Terraform, not your favorite provider X.
- Inclusion of problems. I’d love to have an “Extra for Experts� of challenges for readers to solve to solidify their knowledge.
Overall:
A well written guide through Terraform and it’s associated best practices! Highly recommend.
July 13, 2022
I have been using Terraform at work for a couple of weeks. The setup was created by co-workers and I wanted to dive into this book to learn a bit more about TF on top of what I've already learned via d2d work.
The biggest opportunity that I take away from the book is thinking more about the structure of the TF files. I think the template presented here is pretty good, scalable and at least easier to digest than what I'm currently working on. And we also came to the conclusion that TF state should be broken up into smaller, independent chunks. So that's cool.
The book also helped me to get a better understanding of the basic TF building blocks and how they're ideally used in concert, namely inputs, data, outputs, resources and modules.
One thing where I had hoped to get more out of is the "testing" chapter. I'm not sold on the presented approach. Or in other words: the approach presented here seems a lot of effort compared to what I'm currently working on which also works reasonably well (gitops + pre-prod env + terraform.io and inspecting the plan-output in Github PRs).
All in all it wasn't bad, but I had hoped to get a bit more out of it.
The biggest opportunity that I take away from the book is thinking more about the structure of the TF files. I think the template presented here is pretty good, scalable and at least easier to digest than what I'm currently working on. And we also came to the conclusion that TF state should be broken up into smaller, independent chunks. So that's cool.
The book also helped me to get a better understanding of the basic TF building blocks and how they're ideally used in concert, namely inputs, data, outputs, resources and modules.
One thing where I had hoped to get more out of is the "testing" chapter. I'm not sold on the presented approach. Or in other words: the approach presented here seems a lot of effort compared to what I'm currently working on which also works reasonably well (gitops + pre-prod env + terraform.io and inspecting the plan-output in Github PRs).
All in all it wasn't bad, but I had hoped to get a bit more out of it.
August 7, 2018
I would say that Terraform is the most unsophisticated tool from Hashicorp that I know. However, if you're thinking that's a bad thing then you're wrong.
It does a bunch of things that anyone else who has a glimpse of AWS/Openshift/Azure/etc SDK plus a bit of any scripting language can easily do without loosing a sweat.
But that's its main ace in its sleeve. It does a simple thing and does it very well. It encapsulates all the knowledge about different providers in itself allowing you to use one interface amongst them all.
Considering what Terraform is I would say that this book is too much long and it goes in too much detail. But as with Terraform itself that's not bad because the more you know the less you fear. And this book allows you not fear Terraform and be productive with it since the very beginning.
My score is 5/5
It does a bunch of things that anyone else who has a glimpse of AWS/Openshift/Azure/etc SDK plus a bit of any scripting language can easily do without loosing a sweat.
But that's its main ace in its sleeve. It does a simple thing and does it very well. It encapsulates all the knowledge about different providers in itself allowing you to use one interface amongst them all.
Considering what Terraform is I would say that this book is too much long and it goes in too much detail. But as with Terraform itself that's not bad because the more you know the less you fear. And this book allows you not fear Terraform and be productive with it since the very beginning.
My score is 5/5
February 4, 2021
I like the practical, hands-on approach here -- and esp. that Brikman doesn't shy away from the "soft skills" elements required to on-board a technology like Terraform into your org. (Totally worth a couple pages describing how to build empathy with the managers and directors, find their pain points, and show them how something like this could solve a real world problem. ALSO worth a whole chapter on how to use it as part of a team!)
IaC is something I'm still learning, so there were a few places I needed to double-back and re-read, but I chalk that up to my unfamiliarity with things like AWS and VPCs and subnets...
Would recommend this to Ops engineers looking to get up-and-running with Terraform, as well as software developers with a DevOps mindset that are looking for ways to understand their infrastructure better.
IaC is something I'm still learning, so there were a few places I needed to double-back and re-read, but I chalk that up to my unfamiliarity with things like AWS and VPCs and subnets...
Would recommend this to Ops engineers looking to get up-and-running with Terraform, as well as software developers with a DevOps mindset that are looking for ways to understand their infrastructure better.
March 8, 2023
Best Terraform book hands down! This book covers everything you need to know about Terraform and IaC in general, including best practices, tips, and tricks, as well as common pitfalls and how to avoid them. The technical knowledge is presented in an easy-to-understand manner and the book is very well-organized. Yevgeniy is an avid reader on goodreads, and it shows.
While this book is not a cookbook, it is a great resource for anyone who wants to learn Terraform/IaC concepts and learn them well. The book uses AWS as an example, but the gained knowledge can easily be applied to any cloud provider.
In summary, I highly recommend this book for anyone who wants to deepen their knowledge of Terraform and IaC. It's a comprehensive guide that covers all the essential topics in a clear and concise manner.
While this book is not a cookbook, it is a great resource for anyone who wants to learn Terraform/IaC concepts and learn them well. The book uses AWS as an example, but the gained knowledge can easily be applied to any cloud provider.
In summary, I highly recommend this book for anyone who wants to deepen their knowledge of Terraform and IaC. It's a comprehensive guide that covers all the essential topics in a clear and concise manner.
February 14, 2018
Great kickstart, tutorial-style introduction to Terraform as a tool to manage infrastructure. Since Terraform is very new, some of the content such as gotchas and module design are invaluable resources for teams who want to adopt it in real world, production scenarios.
The part regarding logic constructs (if/else, loops, etc) is also helpful, but feel like a collections of hacks to overcome limitations and achieve reuse which a limited declarative language such as HCL The author makes that point very clear, though.
I recommend for anyone planning on adopting Terraform and have used it before, but not for those who never heard of it or aren't familiar with Infra as a Code (IAC) concepts.
The part regarding logic constructs (if/else, loops, etc) is also helpful, but feel like a collections of hacks to overcome limitations and achieve reuse which a limited declarative language such as HCL The author makes that point very clear, though.
I recommend for anyone planning on adopting Terraform and have used it before, but not for those who never heard of it or aren't familiar with Infra as a Code (IAC) concepts.
December 13, 2018
This book is the reference for Terraform.
The book focuses on AWS provider, and it is a good choice when we know the place Amazon have comparing to other clouds.
You will learn why choosing Terraform among other IAC tools, you will also learn how to use Terraform and the best practices for using it, and that is what make this book unique.
It is well written, and after reading it, you will have a strong basis about Terraform for AWS.
The author has strong skills in many fileds, he is one of the persons who has developped Terragrunt.
It is a must have.
PS : Code on github is written for Terraform 0.8 and 0.9, you will have to modify the first lines that specify the version if you are using a modern version of Terraform.
The book focuses on AWS provider, and it is a good choice when we know the place Amazon have comparing to other clouds.
You will learn why choosing Terraform among other IAC tools, you will also learn how to use Terraform and the best practices for using it, and that is what make this book unique.
It is well written, and after reading it, you will have a strong basis about Terraform for AWS.
The author has strong skills in many fileds, he is one of the persons who has developped Terragrunt.
It is a must have.
PS : Code on github is written for Terraform 0.8 and 0.9, you will have to modify the first lines that specify the version if you are using a modern version of Terraform.
December 21, 2021
Great book as introduction to Terraform and whole Infrastructure as a Code approach. It describes every aspect and feature of the framework, some of them are repeated through whole book to underline their pros and cons. But as it was mentioned, mastering of Terraform can be only achieved by managing real infra through it. If don't have any, do not hesitate to try numerous examples. I found book very helpful also after prod experience. Book is also very good starting point for someone new to DevOps. Somebody who has already some DevOps experience may found some chapters boring, but feel free to skip them, there are plenty references between chapters to already mentioned terms and also a lot of useful links and snippets.
Read
October 8, 2023Read the 3rd ed. Good, but. Good because it covers all the basics, even HCL syntax, and my use case is aws. But: if you are about to use other providers, then write your own examples. And more important: the ideas for production use, such as the folder split and the recommendation not to use workspaces, are based mostly on his personal case without much reasoning. The proposal is not bad, but it's hardly the only one, and the alternative must be evaluated and given its place.
For instance, he proposes to replicate staging and production folders. What if your stack is replicated many more times, all in dev, staging and prod? Replicating folders is hardly the best approach.
But again, good book overall. Just raise your eyebrows at these things and you'll be ok.
For instance, he proposes to replicate staging and production folders. What if your stack is replicated many more times, all in dev, staging and prod? Replicating folders is hardly the best approach.
But again, good book overall. Just raise your eyebrows at these things and you'll be ok.
April 14, 2021
The book does a deep dive in all the features of Terraform and also includes nice bonuses like how to use in a team, how to use it in production and the general overview of Infrastructure as Code and Configuration Management which gives it a great background. Highly recommended to anyone looking to systematize their knowledge about Terraform or learn it from scratch. It's a little shame that the examples were all based on AWS without really touching other providers, but the code samples were mostly up to date and the only problem I had with it has been resolved in the accompanying GitHub repository mentioned throughout the book.
May 5, 2021
This in an excellent introduction to Terraform and HCL. Will you need to reference the documentation on HashiCorps site? Sure. But, I don't understand all the negative reviews on amazon, it does exactly what it claims to do - get you up and running with Terraform. The chapter progression is just right the editing is good with few errors. I wish all O'Reilly books were done this well. The only ding I'm giving is for it's sole focus on AWS. I would have been nice to have seen examples from other platforms, but that's a minor ding. 4.5 stars.
August 4, 2017
Great introduction to terraform. As others have mentioned, it is a tutorial oriented book. As a result it is hard to use as a reference. However, when you use it as it is intended it is great.
Some things are outdated but most things are still relevant (storing state on S3, some syntax). The only thing that is missing for me is the changes you have to make to deploy to a non default VPC. Which can be some digging in the terraform docs if you are working with autoscaling groups.
Some things are outdated but most things are still relevant (storing state on S3, some syntax). The only thing that is missing for me is the changes you have to make to deploy to a non default VPC. Which can be some digging in the terraform docs if you are working with autoscaling groups.
Displaying 1 - 30 of 93 reviews
Can't find what you're looking for?
Get help and learn more about the design.