Throughout this course, you work with a pipeline, taking a web application written in the Go programming language from development to production.
- All right, now that we've covered the basics, let's see how this might work in the real world. - Over the rest of this chapter, we're going to build out a sample continuous delivery pipeline for a web application. This pipeline will walk you through the core components you'll likely need to implement-- - Wait, wait, wait. Before we get started, we should really add a quick note of caution here. No one's pipeline looks the same. - That's right, this is just a sample pipeline. We built it with open source technology to help deliver a sample web application written in Go. - Yeah, now, you may be using Java, Ruby, or Node.js for your application.
- You may be using a mix of open source and commercial software. - Yeah, you may be not delivering web software at all. You might be delivering software in the form of a device driver or mobile games. - But you can benefit from CI and CD, no matter what you're building, or what the unique details of your environment are. - But each product and team, they're going to have to have their own unique challenges for any requirements. - We plan to arm you with the core principles to determine what you need to do to build a pipeline from scratch, or to modify your existing pipeline to increase flow through your build system.
- Now, for this course, we're starting off covering version control, and core practices for development teams when working in continuous delivery environment. For our pipeline, we're going to be using the popular version control system Git, delivered through GitHub. - Then we move into build systems, and cover practices that are important for CI. We'll put it all into practice using the open source build system Jenkins. - Next, we'll move right into handling artifacts, using Nexus for an artifact repository. - We'll hit testing in four main areas: unit, integration, UI, and security testing.
We try to stay away from specific Go testing details, and concentrate on how to test your application from the inside, from the outside, and as a malicious user. - Now, once we're sure our application is tested and ready to go, we'll deploy it via Chef. - Of course, the path through a build system isn't always linear. Each stage is a feedback loop that let's you incrementally improve each change before it gets released. Along the way, we introduce each area with its goal, along with the principles and practices we found to be important and work best in that phase.
- Yeah, and at the end of this course, you should gain a working knowledge of a pipeline, and how you can use this as a roadmap for implementing your own continuous delivery pipeline. - At the end of the course, we'll cover some tips and real world advice for doing continuous delivery in large enterprises, and less than perfect organizations. - Yeah, and that's the really fun part. That's where the rubber meets the road. - For sure. So, next up, we'll talk about version control.
- Benefits of continuous delivery
- Building your own pipeline
- Version control practices
- Building artifacts
- Testing and continuous delivery
- Application deployment and release
- UI testing in action with Robot
- Security testing in action with gauntlt
- CI/CD best practices