TeamCity Tutorial

Teamcity is a Java-based CI server group. TeamCity is a Server-based application that is clear and easy to get to know and has a totally dazzling system encouraged dashboard. TeamCity moreover gives creative progress, drill-down detail, and history information on the endeavors and game plans. 

In TeamCity an entrancing part is Its "Shrewd CI server", which Means it may, therefore, checks work after submission, taking into account our settings. 

TeamCity furthermore reinforces the variation control structures like SVN, CVS, Git, etc.

In this  TeamCity Tutorial, I will be discussing the following topics:

What Is Teamcity? Advantages of TeamCity TeamCity Vocabulary Supported Platforms and Environments of TeamCity Features Of TeamCity Creating a project in TeamCity Adding Visual Studio Adding NUnit Setting Triggers Sending Notifications

TeamCity Tutorial for Beginners

What Is Teamcity?

Teamcity is an integration tool that is written in one of the popular languages: JAVA. It is used to build and deploy different projects that are established by Jet brains, and it is licensed under a proprietary license. Build agent of TeamCity is a piece of software that listens for commands from the TeamCity server and then starts the actual building process. This TeamCity building agent is separately installed from the TeamCity server.

Advantages of TeamCity:

• TeamCity observes multiple branches with various build methods for each branch
• TeamCity is a useful system test runner including test history and identification of problematic or flaky tests
• TeamCity checks status across many projects
• Tool Integration: easy setup, several examples that are existing, great documentation
• TeamCity has a greater ability for troubleshooting and investigation whenever a new code fails
• Very simple to use, updates and upgrades are also easily understandable

TeamCity Vocabulary

• TeamCity Server: The TeamCity server is responsible for managing users, building processes, sending reports, monitoring these are just a small part of the responsibilities of the TeamCity server.
• Build Agent: Build Agent is the "show stopper" of TeamCity. Build Agents do all the truly difficult work expected to assemble and test the task. They are designed through the TeamCity server and can be set up to assemble and run on various stages and working frameworks. A form operator uses the intensity of the machine that it is introduced on.
• Build Configuration: It's the mix of settings used to build an application. In the fabricate setup, you can make manufacturing steps, set triggers, and a variant control framework (VCS) pull for instance.
• Build Step: A single task. Build arrangement typically comprises a few building steps. Each step executes one piece of the assembling procedure. For instance, in one build step, you can incorporate the source code and in the other run tests, or maybe convey the venture.
• Build Trigger: The standard characterizes when the construct ought to be begun. The build trigger can be booked to run at explicit times, naturally on VCS changes, or when different forms are finished.
• Build Artifacts: These describe the results of a victorious build, For example, WAR files, installers, and log files.

If you would like to Enrich your career and get a certified professional, then visit Mindmajix - A Global online training platform: “TeamCity Training”  Course.  This course will help you to achieve excellence in this domain.

Supported Platforms and Environments of TeamCity

When you do constant union with TeamCity then you have a variety of different frameworks, IDEs, platforms, and different tools that will help you build your software project in a better environment.

TeamCity supports runners for Java, .NET, and Ruby of course and you can use order line runners for different languages too. Different tools for checking, code inclusion, code examination, issue following are important pieces of the TeamCity collection and TeamCity itself can be incorporated with a couple of IDEs too.

A portion of the highlights and tools stop as a matter of course packaged with TeamCity and others can be introduced as modules. JetBrains have their own arrangement of modules, however, there are likewise some outsider modules accessible.

Features Of TeamCity:

• Technology Awareness: One explanation TeamCity is named an "Intelligent CI server" is its way to deal with the mix. At the point when we state we support a tool, we mean it inside and out. For instance, support for Visual Studio ventures gives the programmed location of hardware adaptations, testing structures support, code inclusion, static code investigation, and that's only the tip of the iceberg. Also, the best thing is, you get this help without introducing any modules and without any alterations to assemble contents!
• Cloud Integrations: TeamCity exploits distributed computing by progressively scaling out its build operators spread on Amazon EC2, Microsoft Azure, and VMware vSphere.
• Key Integrations: It's difficult to envision an incredible CI and CD server without a mix with some key instruments like your variant control, your issue tracker, your fabricate tool, and your bundle archive. TeamCity pays attention to it simply to offer full help for these key establishments.
• Configuration: skillful programming designers attempt to stay away from code duplication; correspondingly, manufacture engineers evade duplication of settings. TeamCity gets this and gives a few different ways to reuse settings.
• Code Quality Tracking: Helping you accomplish better code quality on your project is a definitive reason for TeamCity. That is the reason it comes bundled with well-known Intelligent IDEA and ReSharper code examination and reviews for Java and .NET code. Significant inclusion tools are likewise bundled and supported out of the case. You can even utilize code quality as a form of disappointment condition.
• User Management: We understand that a CI server is something utilized by an entire group or even an entire organization, that is the reason TeamCity gives the adaptable client the executives, including allocating user jobs, arranging users into gatherings, various methods for user validation, and a log with all user activities for the straightforwardness of all action on the server.

Installing TeamCity:

To know more about installing the TeamCity Click here

Creating a project in TeamCity

So, Let’s see how to create a Brand new .NET project in TeamCity like any other CI server TeamCity relies on VCs, so make certain TeamCity supports your VCs of choice.

• After downloading and installing both the TeamCity server and at least one build agent, you can begin TeamCity. The only primary thing you need to do is begin a new project. You can do this by heading off to the administration page located at the top right corner of the TeamCity board. On the administration page, you will promptly observe two buttons for the project creation. The first one is for the manual creation of the new project and the subsequent(second) one helps you with the procedure by utilizing the URL of the task repository you provided. 
• If you pick manual creation, you will have to fill in the name and classification of the project and also should include the repository URL, but if you opt for creating the project by using the URL then that task will be done by this for you and moreover, it adds a build configuration for you. You can see the review of the build configuration on the general setting page
• The primary thing that you will see when you select the construct design is the general settings page.
• Properties that you want to develop here are the build number arrangement and artifact paths, although you might want to create your own project first so you can simply choose files that will go within artifacts later.
• The build number format is something that you can practice later by requesting %build.number%. It describes the project version: major.minor.build counter.
• Incrementation of the build counter is automatic, but if you want you can reset it any time. For now, let’s neglect the artifacts unimpaired, and move to the next page on the build configurations panel, and this is version control settings.
• If you are creating the project using Repo URL then you can skip this step but if not this is a chance to set up the repository URL that monitors your changes 
• The following phase of build configuration is the build steps definition. The build steps page gives you the alternative to naturally distinguish assemble projects for your task, or you can include them individually physically. 
• Automatic build step discovery is helpful if TeamCity handles the project runners by default. Unless, you can pick among many build tools like Ant or NAnt, or simply use the command line or Powershell. This is where you can set up scripts and tests, do the deployment and code analytics.
• Few of the tools you want are encouraged by TeamCity by default, others need to be supplemented using the TeamCity plugin manager.

Adding Visual Studio:

Before we can bundle and appropriate our application, we have to build it first. So as to do this, we are going to include the build step and afterward pick the Visual Studio (sln) choice option from the drop menu. After that you should see something like this:

After entering the name select the path to the path solution file.

Adding NUnit:

Since we have the build step arranged, we can add the test runner to our task. The most well-known testing tools for .NET projects are xUnit and NUnit. While NUnit comes packaged with TeamCity as a matter of course, in the event that you use xUnit in your project you have to introduce it as a module. 

Suppose for instance your project is utilizing NUnit structure. To consequently run tests for your project, you can go to the Add build step button once more, and starting from the drop menu select the NUnit. At the point when you do that, TeamCity will create a couple of properties you have to arrange so as to run your tests. Your page should resemble this:

Setting Triggers:

If you observe the below picture you’ll see the bulb near the run button, This tiny light bulb is striving to tell you that you skipped adding the VCS trigger to your project.

If you click this bulb it directs you to a page where you can select a trigger of your choice. For now, there are two triggers you need to care about

• VCs trigger
• Schedule trigger

VCS trigger detects the changes in the VCS repository and Schedule trigger is used to schedule your build at regular intervals.

Sending Notifications:

To send the Notifications, you should initially set the email notifier in the administration segment of TeamCity. When you set the SMTP settings, you have to go to the My Settings and Tools segment that you can discover in the drop-down underneath your profile name. After that, go to the notification rules tab, and just add the rule you need to the proper user groups.

Notification settings are quite adaptable so use them to your inclination. In any event, you ought to get a notification when the build fails flat, so you can fix the issue rapidly.  

Conclusion

TeamCity was begun in 2005 out of our own need to have an adaptable and incredible nonstop and continuous integration server that could convey functionality through the contributions that were accessible at that point. From that point, a great part of the functionality in TeamCity has been as much of our requirements as that of our users, as we keep on utilizing it all through JetBrains day by day.

If you have any doubt of difficulty level in TeamCity then here is my answer, 

TeamCity is developed by JetBrains and is the base language used in JAVA. So, it is very easy to develop and create projects on it.