Getting Started with TeamCity

In this course you'll learn everything necessary to automate application builds, testing, and deployment of software with TeamCity.
Course info
Rating
(78)
Level
Beginner
Updated
Nov 8, 2016
Duration
4h 3m
Table of contents
Course Overview
Setting up TeamCity
Creating Application Builds
Automating Builds for Fast Feedback
Chaining Builds to Perform Parallel Integration Testing
Deploying Software with the Build Chain DSL
Description
Course info
Rating
(78)
Level
Beginner
Updated
Nov 8, 2016
Duration
4h 3m
Description

Developing software involves many processes to get code from development into a production environment. TeamCity helps you automate every step of this process. In this course, Getting Started with TeamCity, you'll learn how to set up application builds to compile, test and package your apps. First, you'll see how to kick off this process every time someone checks in code and get notifications when something fails. Next, you'll explore how to get high-level reporting about failures. Finally, you'll learn how to create templates for reusable build processes and how to rapidly automate an entire delivery pipeline. By the time you're done with this course, you'll have everything you need to automate taking your software from development through to production with TeamCity.

About the author
About the author

Wes Higbee is passionate about helping companies achieve remarkable results with technology and software. He’s had extensive experience developing software and working with teams to improve how software is developed to meet business objectives. Wes launched Full City Tech to leverage his expertise to help companies delight customers.

More from the author
What Is DevOps: Executive Briefing
Beginner
22m
Nov 2, 2018
Implementing a Self-hosted Docker Registry
Intermediate
4h 8m
Jun 5, 2018
Webpack: Transpiling and Bundling JavaScript
Intermediate
4h 55m
Jan 30, 2018
More courses by Wes Higbee
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi, my name is Wes Higbee. Welcome to my course Getting Started with TeamCity for continuous delivery. Somehow, software has to get from our development environment into the hands of our users and a production environment. There are many steps on this journey from development through to production and that's what we'll take a look at in this course with the help of TeamCity. First we'll take a look at how we can set up TeamCity in a variety of environments. We'll then use TeamCity to create application builds by setting up an automated build processes inside of TeamCity, much like a manual build process. Once we have that set up, we'll take a look at what's it's like to get feedback quickly from this environment. Oftentimes we have complex testing, so next we'll take a look at how we can set up parallel integration testing within TeamCity to start to form a deployment pipeline. And then in the last module of this course we'll take a look at how we can continue our pipeline through to deploying software. So that we have an automated process that can take software from development through to production. By the time you're done with this course you'll have the expertise necessary to use TeamCity to automate just about anything you can think of when it comes to developing and releasing your software.

Creating Application Builds
Now that we have TeamCity set up, let's put it to use to build some application code. Before we dive into this demo, let's first walk through the Anatomy of a Build Process. First, we're going to clone our application source code from GitHub, we'll clone that into a local workspace, a folder that we create on our hard drive. Once we have that code, then we'll compile it, to make sure that it compiles, we'll run unit tests on it to make sure it's healthy code, and then we'll package up the result, and in this case, we'll produce a JAR file. This is the process we're going to work with, first manually, so we can see the commands that are involved, and then we'll port those manual commands over to automation, inside of TeamCity. Let's get started by cloning our code from GitHub.

Automating Builds for Fast Feedback
We now have a robust process set up that automates building our application. However, if you're like me, you're probably not going to remember to come out and run this every time someone checks in code. So, if you don't do anything else, you'll probably just forget that you have this set up and it won't be of much value to you. Because of this, in this module we're going to learn how we can set up further automation that kicks off this entire process automatically. We'll dive into a little bit more about test results in terms of the TeamCity UI. And we'll also take a look at getting notifications. That way we never have to come to TeamCity unless there's a problem. In the process of doing this, we're also going to look at a. NET build. So we'll switch gears and start on a new project type. So in addition to fast feedback, at the end of this module you're going to better understand some of the similarities and differences between languages and platforms when you're setting up an application build process. Now even if you don't intend to use. NET in your daily work, it's still good to get your hands on these examples. Just like if you were a. NET developer, it's good to get your hands on the Java examples. In doing this, you start to learn some of the commonalities of application build processes. You should become much more confident that you can set these processes up, regardless of the language, platform, or tools involved.