Getting Started with TeamCity

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.