TeamCity Training

About

Nowadays, Agile application development is usually done at a fast pace when many developers are working on the same piece of code. Every so often, this becomes a real challenge if there's no permanent control over consistency of the project source. It is often impossible to force lazy and/or busy programmers to execute tests before and after each of their commits. Continuous Integration is a well-known life saver for distributed development environments with TeamCity being one of the best and easy-to-use instruments utilizing it.

"TeamCity" is kind showing in a sequential approach - how to start implementing Continuous Integration - over generic projects and enclosing rich features of the TeamCity as a project gradually evolves

Objectives

In this course we will:

  • Learn about CI and why it is important
  • Learn about TeamCity
  • Build an automated CI pipeline with TeamCity
  • Learn how to version control and manage relational database schema
  • Run the CI pipeline to maintain build artifacts
  • Learn how to configure, secure and extend TeamCity
  • Learn how to configure automated build notifications
  • Integrate CI builds with Git repositories hosted in GitHub

What am I going to get from this course?

  • Learn what is continuous integration (CI)
  • Learn why continuous integration is important (especially in fast paced startup environment)
  • Learn how valuable TeamCity skills are
  • Maintain and version control database schema in an automated fashion via RoundHousE
  • Install and configure TeamCity on Windows and Linux platforms
  • Build and automated CI pipeline with TeamCity for .NET and Java platforms
  • Learn how to setup automatic building notifications within Teamcity
  • Integrate CI builds with Git repositories hosted in GitHub​

Pre-requisites

What are the requirements?

  • Access to a physical or virtual machine to install the required software
  • Basic information about software development processes
  • Desire to learn something new and continuous improvement
Classroom Training Pre-requisites Click Here

TeamCity Training Flow

Number of Days - 4
Day 1

  • ✔ Introduction of DevOps Concept and Process
  • ✔ Introduction of Source Code Management - Git and Lab
  • ✔ Introduction of Source Code Management - Ant and Lab
  • ✔ Introduction of Source Code Management - Maven and Lab
  • ✔ Introduction of Source Code Management - MSBuild and Lab
  • ✔ Introduction of Source Code Management - Gradle and Lab
  • ✔ Continous Integrtion and Delivery
  • ✔ Team City Installation and Configuration and Lab
  • Day 2
  • ✔ TeamCity Fundamental and Lab
  • Day 3
  • ✔ TeamCity Advanced and Lab
  • Day 4
  • ✔ TeamCity Administrator and Lab
  • Features

  • ✔ 30 Hours instructor led online class
  • ✔ Hands on Approach - We emphasize on learning by doing.
  • ✔ Life time free re-enrollment to future DevOps courses
  • ✔ Life time free access to all learning materials including
  • ✔ Class recordings
  • ✔ Presentations
  • ✔ Sample Code
  • ✔ Projects
  • ✔ Total Lab Infrasture in cloud and 24x7 available
  • ✔ 70% of the class is consist of Lab
  • ✔ Each week assignments(total 4) with personal assistance
  • ✔ Two real time senario based projects with standard evaluation
  • ✔ 24x7 online support to queries during and after the course completion
  • ✔ 1 dedicated class for Interview preparations
  • Agenda

    1. Introduction to Continuous Integration
    • Practices
    • Benefits
    • Continuous deployment and Continuous Delivery
    • The build pipeline
    2. Introduction to TeamCity
    • Licensing
    • Features
    • First-class support for various technologies
    • Lots of plugins
    • REST API
    • Comprehensive VCS support
    • A nice dashboard UI and build history
    • Ease of setup and comprehensive documentation
    • Build pipeline/chains
    • Agents and build grids
    • IDE integrations
    • TeamCity and its competitors
    • Jenkins
    • ThoughtWorks' Go
    3. Installation
    • Installing on Windows
    • Installing the server and the default agent
    • Installing additional agents
    • Installation on Mac OS X
    • Running the TeamCity server and the default agent
    • Setting up the TeamCity server as a daemon
    • Installing additional agents
    • Installation on Linux
    • Running the server and the default agent
    • Running the TeamCity server as a daemon
    • Installing additional agents
    • Summary
    4. Getting Your CI Up and Running
    • Introducing version control systems
    • Centralized versus distributed VCSs
    • VCSs and CI
    • VCS used in this book
    • Setting up CI
    • The sample project
    • Creating a project in TeamCity
    • Subprojects
    • Adding build configurations
    • VCS roots and VCS settings
    • Introducing the build steps
    • Running our first build
    • Build failure conditions
    • Triggering the build on VCS changes
    • Build chains
    • Deploying to Heroku
    • Adding functional tests
    • Parameters and build parameters
    • Setting up the build chain
    • Snapshot dependencies
    • The Finish build trigger
    • The Build chain view
    • Fine-tuning our setup
    • Adding coverage and unit test reports
    • Publishing reports as artifacts
    • XML report processing
    • Report tabs
    • Build and project statistics
    • Shared resources
    • Agent Requirements
    • Summary
    5. TeamCity for Java Projects
    • Using Ant with TeamCity
    • Installing Ant
    • Building with Ant build files
    • Building with Ant in a build configuration
    • Adding some unit tests
    • Setting up code coverage
    • Build scripts versus TeamCity features
    • System properties and Ant
    • Using Maven with TeamCity
    • Installing Maven
    • Creating a Maven project
    • Introducing the Project Object Model (POM)
    • Building the project
    • Using Maven in a build configuration
    • Setting version number
    • Setting up code coverage for our build
    • Maven on TeamCity, beyond the build runner
    • Creating a Maven build configuration
    • Global Maven settings file
    • Setting up Maven-based triggers
    • Using Gradle with TeamCity
    • Installing Gradle
    • Building with Gradle on TeamCity
    • Introducing database migration tools
    • Summary
    6. TeamCity for .NET Projects
    • Getting started with NAnt on TeamCity
    • Installing NAnt
    • Building NAnt with NAnt
    • Building on TeamCity
    • Adding NUnit report processing
    • Configuring agent requirements
    • Building with MSBuild
    • Installing MSBuild
    • Starting an MSBuild project
    • Building with MSBuild on TeamCity
    • Adding an NUnit build runner
    • Running NUnit tests using NUnit task
    • Running NUnit tests using the task provided by TeamCity
    • Configuring code coverage with MSBuild
    • NuGet and TeamCity
    • Installing the NuGet command-line client
    • Installing NuGet.exe on TeamCity agents
    • TeamCity as a NuGet server
    • NuGet-based build runners
    • NuGet dependency trigger
    • Introducing PowerShell
    • PowerShell-based build tools
    • PowerShell build runner in TeamCity
    • Database migrations with .NET
    • Summary
    7. TeamCity for Ruby Projects
    • Getting started with Rails
    • Managing Ruby versions
    • Introducing Bundler
    • Installing Rails using Bundler
    • Introducing Rake
    • Setting up the build on TeamCity
    • Setting up Ruby interpreter
    • Running Capybara- and Selenium-based feature tests
    • Summary
    8. TeamCity for Mobile and Other Technologies
    • CI for Android projects
    • Generating the APK
    • Running Calabash tests
    • Building iOS projects on TeamCity
    • Installing TeamCity plugins
    • Installing the Python runner plugin
    • Building with the Python build runner
    • Introduction to TeamCity.Node plugin
    • Summary
    9. Integration with Other Tools
    • IDE integrations
    • IntelliJ platform IDEs integration
    • Installing the plugin
    • Configuring notifications
    • Managing projects from the IDE
    • Opening files and patches in IDE
    • Remote Run
    • Visual Studio integrations
    • GitHub integrations
    • GitHub webhooks and services
    • Using the TeamCity.GitHub plugin
    • Support for pull requests
    • Integrating with GitHub issue tracker
    • Build monitors
    • Team Piazza
    • Project Monitor
    • Build lights
    • Notifications
    • Summary
    10. TeamCity for a Member of the Team
    • Managing projects of interest
    • Hiding projects
    • Hiding build configurations
    • Navigating across projects
    • Investigating investigations
    • Assigning investigations
    • Viewing active investigations
    • Managing current and muted problems
    • TeamCity universal search
    • Actions on build configurations
    • Pausing triggers in a build configuration
    • Checking for pending changes
    • Enforcing clean checkout
    • Summary
    11. Taking It a Level Up
    • Build configuration templates
    • Creating templates from scratch
    • Creating build configurations from the template
    • Creating templates from existing build configurations
    • Going meta with Meta-Runners
    • Using Meta-Runners
    • Build result actions
    • Commenting on build results
    • Tagging build results
    • Pinning build results
    • Promoting builds
    • Marking the build as successful or failed
    • Removing builds
    • Build history cleanup
    • Cleanup rules
    • Archiving projects
    • Configuring build priorities
    • Interacting with TeamCity from build scripts
    • Service messages
    • Creating teamcity-info.xml
    • Summary
    12. Beyond CI - Continuous Delivery
    • What is Continuous Delivery
    • Why Continuous Delivery
    • The deployment pipeline
    • Implementing the deployment pipeline in TeamCity
    • Publishing and consuming artifacts
    • Build chain for CI
    • Deploying to environments
    • Environments as gates
    • Identifying the build that is deployed in an environment
    • Deploying any version to an environment
    • Limiting deployment permissions to certain users
    • Passing sensitive information during deployment
    • Feature branching and feature toggling
    • Summary
    13. TeamCity Administration Part 1
    • Using TeamCity with an external database
    • Configuring PostgreSQL as an external database
    • Migrating from one database to another
    • Backup and restore
    • Taking backups from the server UI
    • Backing up and restoring data using the maintainDB tool
    • A manual backup
    • Handling upgrades
    • Updating a server installed via an archive
    • Updating TeamCity using the Windows installer
    • Updating the agents
    • Monitoring resource usage, performance, and logs
    • Disk space usage
    • TeamCity server diagnostics
    • Tweaking the TeamCity JVM
    • Summary
    13. TeamCity Administration Part 2
    • TeamCity Configuration and Maintenance
    • Managing Projects and Build Configurations
    • Managing Licenses
    • Integrating TeamCity with Other Tools
    • Managing User Accounts, Groups and Permissions
    • Customizing Notifications
    • Assigning Build Configurations to Specific Build Agents
    • Patterns For Accessing Build Artifacts
    • Mono Support
    • Maven Server-Side Settings
    • Tracking User Actions

    Active Tab:

    Previous Tab: