Continuous Integration with TeamCity

2 Day Classroom  •  2 Day Live Online
2 Day Training at your location.
Adjustable to meet your needs.
Group Rate:
GSA Discount:
When training eight or more people, onsite team training offers a more affordable and convenient option.
Register Now
Request Quote

Continuous integration helps teams work better together. By creating a system where members of a development team can integrate their code for building and testing on a continuous basis, conflicts are caught quickly or even prevented before they occur.

TeamCity provides teams with this capability and more. It’s a multiplatform, multi-language CI server that integrates into your developer’s workflow and provides them with real-time information about builds, tests, and deployments.

In this TeamCity Training course, you will learn how to:

Create a TeamCity project with a repository URL
Commit breaking code to version control system
Add a project to overview page
Build number counter, number formats, and variables
Deeply examine various test results
Build different configuration types: regular, deployment and composite
Deploy Maven and NuGet packages and Docker images
Configure and maintain TeamCity
Upcoming Dates and Locations
Guaranteed To Run

There aren’t any public sessions currently scheduled for this course, but if you fill out the form below, we can tell you about how we can bring this course to you!

Course Outline

Part 1: Introduction

  1. What is TeamCity?
  2. What is continuous integration?
  3. TeamCity capabilities
    • Build and deploy automation
    • Version control system integration
    • Static analysis and code coverage
    • Reporting
  4. Supported platforms and environments
  5. Licensing and cost

Part 2: Creating a project

  1. Logging in to TeamCity
  2. Create a TeamCity project with a repository URL
    • TeamCity analyzes build file
    • Select desired build step
  3. Add project to overview page
  4. Run build
    • View test results
    • View build log
  5. View build configuration options
    • Build number counter 
    • Build number format and variables
    • Build triggers— a brief overview of what they are
    • Artifact paths
  6. Pre-test a change
    • IDE integration
    • Remote run a change
    • Show “personal build” on TC
  7. Commit breaking code to version control system
    • Observe build being triggered and failing
    • Create investigation and assign to self
  8. Fix build

Part 3: Projects and builds

  1. Projects
    • Settings
    • The project hierarchy
  2. Build configuration types
    • Regular
    • Deployment
    • Composite
  3. Build configuration settings
    • Version Control System configuration
      • GitHub, Bitbucket, Team Foundation support
      • Feature branches
      • Multiple repositories
    • Build steps—overview of bundled runners
      • .NET Cli          
      • Gradle
      • Ant
      • Command line
      • Maven
      • MsBuild
      • Others
      • Advanced configuration—run in a container
    • Build Triggers
      • What is a build trigger?
      • Repository changes
      • Schedules
      • Dependency changes (Maven, NuGet, etc.)
      • Retry or build finish triggers
    • Failure conditions
      • Maximum build duration
      • Error message in build log
      • Metric changes
        • Artifact size
        • Class count
        • Number of failed tests
        • Code coverage minimums
    • Build dependencies
      • Snapshot dependencies
      • Artifact dependencies
    • Build Features
      • Docker support
      • NuGet credentials
      • Free disk space
    • Build Parameters
      • Environment variables
      • System properties
      • Configuration parameters
    • Logs
      • Change logs
      • Build logs

Part 4: Manually Add Project

  1. Create new project
  2. Add name
  3. Add repository URL
  4. Configure build (Gradle—see notes)
    • Select build type
    • Add build step for clean
    • Add step for build
    • Build file name
    • Gradle home
  5. Review advanced options
    • Debug options
    • Logging options
    • JDK version options
  6. Run build
  7. View results

Part 5: Tests

  1. Framework support
    • Java/.NET/Ruby
    • Plugins
    • Adding support for custom tests
  2. Test results
    • Deeper examination of changes and ties to VCS
    • Deeper examination of build logs
  3. “Flaky” tests
  4. Investigations
  5. Exercise: more complex tests
    • Add a more complex project with tests
    • Make tests fail
    • View logs and changes
    • Start investigation
    • Clear build problem

Part 6: Code inspection configuration

  1. Bundled code inspection tools
    • IntelliJ Java code inspections
    • Resharper .NET Code Analysis
  2. Viewing reports
  3. Exercise:
    • Add analysis build step with IntelliJ inspector
    • Run build
    • View report

Part 7: Deployment builds

  1. Deploy Maven packages
  2. Deploy NuGet packages
  3. Deploy Docker images
  4. Exercise: deploy Docker image
    • Verify agent is available with Docker support
    • Add project with a Dockerfile
    • Add/view Docker build step
    • Run build
    • Pull docker image from Docker hub and run

Part 8: Customization

  1. VCS accounts
  2. Notifications
    • Rules
    • Mechanisms
  3. IDE integrations
    • IntelliJ
    • Visual Studio
    • Eclipse

Part 9: TeamCity administration

  1. User profile customization
  2. Installation and configuration (See notes)
    • Install on Windows
    • Install on Linux/Mac
    • Install on Docker
    • Install in cloud
    • Creating users
  3. Configuration
    • Notifications
    • Plugins
    • Database support
  4. Administration
    • Authentication
Who should attend

This TeamCity training course is designed for the following professionals:

  • Software Developers
  • Project Managers
  • Quality Assurance Professionals
  • Software Testers
  • Product Owners
  • Business Intelligence Professionals
  • Infrastructure Engineers
  • Development Team Members
  • Operations Team Members
  • Anyone who is a hands-on user of the TeamCity Platform

Download the brochure