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
COURSE 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
- 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
FEATURES
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
Introduction to Continuous Integration
- Practices
- Benefits
- Continuous deployment and Continuous Delivery
- The build pipeline
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
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
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
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
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
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
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
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
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
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
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
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
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
![]() ![]() ![]() |
---|