Infrastructure from Code: The Big Picture

Infrastructure from Code removes human related problems by providing management and provisioning of the Data Center through machine read configuration files. This provides a repeatable, recoverable and often times, more secure Data Center.
Course info
Rating
(38)
Level
Beginner
Updated
Jun 14, 2017
Duration
1h 32m
Table of contents
Description
Course info
Rating
(38)
Level
Beginner
Updated
Jun 14, 2017
Duration
1h 32m
Description

IT Ops has traditionally managed servers and the infrastructure through human actions, which often causes delays and mistakes from updates to deployments. Infrastructure from Code removes the human related problems by providing management and provisioning of the Data Center through machine read configuration files. This provides a repeatable, recoverable and often times, more secure Data Center. In this course, Infrastructure from Code: The Big Picture, you'll learn about the concepts of DevOps, and the process and tools of Infrastructure from Code. You'll delve into learning about automating your processes with a Release Pipeline, how it can shift the performance of IT Ops, and finally a variety of tools to start building repeatable, safe, and reliable deployments. When you're finished with this course, you'll have a starting point to move past this overview and into building your own Release Pipeline for Infrastructure from Code.

About the author
About the author

Jason Helmick is an author for Pluralsight. His IT career spans more than 25 years or enterprise consulting on a variety of technologies, with a focus on strategic IT business planning. He’s a highly successful IT author, columnist, lecturer, and instructor, specializing in automation practices for the IT pro.

More from the author
More courses by Jason Helmick
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
IT Ops has traditionally managed servers and the infrastructure such as messaging and authentication through human actions, tying up valuable resources and causing delays. Humans also make mistakes and can be slow to recover from them. Hi I'm Jason Helmick, and I want to introduce you to a component of DevOps that can change all of that, known as infrastructure from code. You will learn how automating your processes with a release pipeline can dramatically shift the performance of IT operations, providing a repeatable and safe process for deploying and updating your servers and infrastructure services. In this big picture course, you will understand the four stages of the release pipeline, and be introduced to the available tools for each stage. Now if you're ready to improve your deployment time, and prove recovery time, and lower the failures due to change, this is the place to start. So from all of us here at Pluralsight, we love to learn, and I hope you do too.

Stage 1: Source
Let's say for a moment that you needed to write a document, a report for something that you were working on, when you were writing the report, do you occasionally you know write a couple of paragraphs and then maybe save that off, because that's really good, and then you'll edit it later and save off a different version, or let me put it this way, maybe you already do some automation, maybe you do some scripting, so you write a script that does something, and it works, it works great, but now you need to change the script to add something else to it, maybe a new feature that you want added in, do you save that original auth, just in case it breaks, so that you can roll back to it? This is the concept behind source, or really what we're talking about here is source control. Now, developers, they've been doing this for a very long time, this is a way for them to you know, roll back to things if something should go wrong, but IT ops has been a little bit slower to embrace this, and I'm really not too sure why, because as somebody in IT ops, my code, the code that I write, is just as valuable as a developers, and I want to be able to roll back to, and that's just one of the features of this, but this is the concept of what we're looking at, so when we're looking at creating our configurations, we're looking at the idea of putting them into source control, and so this is what we're going to do, define what source really is, and then we're going to talk about something, another term that you'll hear for it besides source control is version control, but specifically what versioning is, and then something that might be a part of source as well, which is code review. So what do you say we get started with defining what is source?

Stage 2: Build
The build stage is where we're going to take what we put into source, our configurations that we have there, and turn them into machine readable, usable configuration documents. So, if you are an app dev, this would be where you would actually compile your code, your build server would make the executables or the finished product that could now go further down the pipeline towards release, and that's really what the idea is behind build. Now as an overview, of course yeah, we're going to take a look at turning code into product, we'll look at how the build stage might get triggered, there's a couple of different ways that you could trigger this besides manually, and we'll look at that, scheduled versus manual builds. So let's dive in with turning code into product.

Stage 4: Release
The last stage in our process is release, and this means different things for different people. For an app dev, a developer, release might mean you know copying files out to a web server and the new website comes alive, for an IT ops person, this might mean the same thing, or it might actually mean building brand new machines out in the infrastructure, and applying a configuration to them. So, this has a little bit different meaning, therefore there's going to be different processes that are going to be unique to everyone in part of this release stage, but that's what we want to take an overview of right now. And, what we're going to do is we're going to take a look at what does release actually mean to us, and we're going to look at a couple of concepts of Continuous Delivery and Continuous Integration. So let's get started with what does release actually mean?

A Final Word
If you've been following along throughout this course, you'll kind of notice that yes, this is the big picture overview and you've gotten a lot of concepts out of this and even some ideas of products that you can start to research and you can start to look at these different stages, and I hope you really find this helpful, but I also know that there's more work to do. So I want to remind you about some key components or key parts of information, and also maybe give you a way that might be helpful to get started so you can start to work on building your own release pipeline. As an overview for this, I just want to remind you about the benefits and about the overarching concept behind this DevOps, and Infrastructure from Code, our release pipeline as it is, and remind you about that view of failure, I know that's a tough one but yes, and then how to get started. So why don't we start off with a quick review on the benefits, and put them into a new concept now that we've seen the entire release pipeline, and then look at how to get started.