Today in this article, we will see how to Identify Azure Pipeline Id For Devops In ADO.

We will see 2 simple approaches to find the pipeline ID.

In the first approach, we will use the AZ command to get details about the pipeline, and 2nd is a more kind of manual approach to get the Ids.

Today in this article, we will cover below aspects,

Approach 1- Using AZ command to get the pipeline ID and other information

Command

az pipelines show --organization <your org name> --project <project name> --name <name>

Example

az pipelines show --organization https://dev.azure.com/jan2022-thecodebuzz --project globalexceptionhandler --name globalexceptionhandler

As highlighted below, the response from the API shows the Id returned as 5

While using the above command you might need to log in again to confirm the connections setting ,

Approach 2- Using ADO Pipeline Edit command to pipeline ID and other information

You can also use the ADO Pipeline Edit command to get pipeline ID and other information manually as shown below,

Once you click on EDIT, you can find the pipeline ID with the URL below,

References:

• Create HTTP with NGINX on Linux in Azure Virtual Machine

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Identify Azure Pipeline Id For Devops In ADO first appeared on TheCodeBuzz.

Today in this article, we will see how to use API for automating Azure DevOps ADO Build Pipelines process.

We will see an example of how to trigger Azure Pipelines build via API.

We will look over all 2 approaches to achieve the same,

• Build -Queue API

• Runs – Run Pipeline API

Today in this article, we will cover below aspects,

We will use the below API for the same.

Trigger an ADO build- using Queue API

Calling POST API

POST https://dev.azure.com/{organization}/{project}/_apis/build/builds?api-version=7.1-preview.7

Build pipeline With optional parameters

We can build a pipeline With optional parameters as explained in below example,

Calling POST API

POST https://dev.azure.com/{organization}/{project}/_apis/build/builds?ignoreWarnings={ignoreWarnings}&checkInTicket={checkInTicket}&sourceBuildId={sourceBuildId}&definitionId={definitionId}&api-version=7.1-preview.7

Input Parameters Explained

In the above Post request below are the input parameters,

• organization – The name of the Azure DevOps organization.

• project – Project ID or project name

• api version – Version of the API to use.

Request Body

• definition – The build number/name of the build.

Below is our sample repository,

https://dev.azure.com/jan2022-thecodebuzz/globalexceptionhandler/_build

Configuration and security

Let’s now configure the API to be invoked securely.

Step 1- Click on the User settings and set up the personal access token.

Define a name for this token and authorize the scope of access with this token. You can choose this token access for the Build pipeline trigger or release pipeline trigger etc.

Finally below is our URL and input request object defined,

Define URL

https://dev.azure.com/jan2022-thecodebuzz/globalexceptionhandler/_apis/build/builds?api-version=7.1-preview.7

Let’s now use Postman to execute the API. Please set up the Basic authentication in the Postman by setting up the Token name as UserName and Password as a personal access token.

Below is my request body,

{ 
        "definition": {
            "id": 5
        } 
}

Once you execute the POST API, please check your pipeline. You shall see it is executed and triggered for a build successfully,

References:

• Automating Azure DevOps Build Pipelines using Run Pipeline API

• Create HTTP with NGINX on Linux in Azure Virtual Machine

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post API for automating Azure DevOps ADO Build Pipelines – Part 1 first appeared on TheCodeBuzz.

Today in this article, we will see how to use API for Automating Azure DevOps Build Pipelines using Run Pipeline API.

We will see an example of how to trigger Azure Pipelines build via API. AS we learned in the last article we have below two approaches to call REST API for Build pipeline,

• Build -Queue API
• Runs – Run Pipeline API

We already looked at the Build queue approach in the previous article.

Today in this article, we will cover below aspects,

For more details please see below article,

• API for automating Azure DevOps Build Pipelines – Part 1

Both approaches have similar settings/configuration steps and hence they are easy to configure.

Trigger a build using – Run Pipeline

Build pipeline

POST https://dev.azure.com/{organization}/{project}/_apis/pipelines/{pipelineId}/runs?api-version=6.0-preview.1

Build pipeline With optional parameters

POST API

POST POST https://dev.azure.com/{organization}/{project}/_apis/pipelines/{pipelineId}/runs?pipelineVersion={pipelineVersion}&api-version=6.0-preview.1

Input Parameters

In the above Post request below are the input parameters,

• organization – The name of the Azure DevOps organization.

• project – Project ID or project name

• api version – Version of the API to use.

Request Body

• definition – The build number/name of the build.

Below is our sample repository,

https://dev.azure.com/jan2022-thecodebuzz/globalexceptionhandler/_build

Configuration and security

Let’s now configure the API to be invoked securely.

Step1- Click on the User settings and set up the personal access token.

Define a name for this token and authorize the scope of access with this token. You can choose this token access for Build pipeline trigger or release pipeline trigger etc.

Finally below is our URL and input request object defined,

URL

https://dev.azure.com/jan2022-thecodebuzz/globalexceptionhandler/_apis/pipelines/5/runs?api-version=6.0-preview.1

Let’s now use Postman to execute the API. Please set up the Basic authentication in the Postman by setting up the Token name as UserName and Password as a personal access token.

Request Object for Build Pipeline API

Below is my request body,

{
    "resources": {
        "repositories": {
            "self": {
                "refName": "refs/heads/master"
            }
        }
    }
}

Response from Build Pipeline API

Below is a sample response,

Once you execute the POST API, please check your pipeline. You shall see it is executed and triggered for a build successfully,

References:

• API for automating Azure DevOps Build Pipelines – Part 1

• Create HTTP with NGINX on Linux in Azure Virtual Machine

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

The post Automating Azure DevOps Build Pipelines using Run Pipeline API first appeared on TheCodeBuzz.

Today in this article, we will see how to Highlight Bash, and shell code in Markdown Readme.md files, or wiki files for Git.

Today we will cover below aspects in this article,

We shall cover a few useful commands used for various CLI tools like,

• Shell
• Bash
• Powershell
• DOS

Command Pattern

Below is the general pattern for highlighting the code using the language of your choice,

```<Language>

///Your code here 

```

Shell – Using Console for bash/shell code in Markdown

Highlight Bash/shellcode in Markdown files using console commands can be done using below naming pattern,

Example

```console

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.



```

GitHub preview

Below is how the preview looks with syntax highlighter in GitHub,

Bash – Using Bash/shell command in Markdown

HighHighlight Bash/shellcode in Markdown files using bash/shell commands as below,

```sh

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```

OR

```bash

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```

Powershell – Using the Powershell command in Markdown

We can also Highlight Bash/shellcode in Markdown files using PowerShell commands as below,

```powershell

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```

Using DOS- Using Powershell command in Markdown

We can use DOS commands like dos, bat, cmd

Example

```bat

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```




```cmd

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```




```DOS

thecodebuzz@DESKTOP-NUEMRRD:~$ sudo service redis-server restart
Stopping redis-server: redis-server.
Starting redis-server: redis-server.

```

That’s All,

References:

• Add images to README Git – Guideline

• Chery pick in Git with example

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Highlight Bash, shell code in Markdown Readme.md files first appeared on TheCodeBuzz.

Cherry-pick in Git (Version Control System) is a technique of picking up a commit from a branch and applying it to another branch.

If used correctly Cherry-pick can address multiple use cases like bug fixing or patching purposes or undoing the changes.

Apart from this Cherry-pick could also be useful in code collaboration.

Today in this article, we will cover below aspects,

Cherry-pick concept is common to services like GitHub or ADO, Git Lab or Bit Bucket which are built on top of Git which is open source VCS( Version Control System)

Why cherry-pick?

In Git, you a cherry-pick for any of the below use cases.

These below characteristics could be any of the below and not limited to,

• Picking a commit and applying it at the appropriate place typically a branch
• Bug Fix/Patch on a released branch.
• Undoing the changes
• Cherry-pick with the intention of code reuse
• Collaboration in a team with code sharing.
• Reverting back to the previous best version (as it was a good code before someone introduced a bug ).

Picking up code from one branch to another branch is not dependent on the branching model following. You could follow,

• TBD (Trunk Based Development)
• GitFlow or any other legacy way of multi-branch type to support multiple branches.

Cherry-Pick in Git- Step by step

Trunk Based Development

Let’s understand the example above.

The above example might resemble Trunk Based Development but the concept we shall be learning can be applied to any approach.

If you are not following Trunk based branching, please refer to section @7 Perform cherry-pick directly which explains a simple 2 step process for performing cherry-pick from one branch to target the branch.

The above example shows that,

• The project was released as per the plan for @3 commit.

• The released project was tagged as @R (Code released on May 23)

• A bug was reported requiring an immediate fix. ( Bug reported on June 5 )

• The main branch already progressed in developing new other functionality with @4-5 and 6 commits.

When Code was released @3, it had only 1 file (ValuesController.cs) and now the code has 3 more new files as shown below.

There is a bug in the file ValuesController.cs that needs to be fixed.

This fix is urgent and needs to be applied to the release branch @R1

1. Check Out @ 3 commit

• Get the commit ID for a commit @3.

Ex. This commit ID is ‘914c9fac373ae3a27ce1025943664a0e04f550a4’

Command :

git checkout - b [branch-name] [commit-id]

Successful execution of the above command will bring the released codebase where we would be applying a bug fix.

Let’s modify the code now. The changes are highlighted below,

@3B Apply Code changes for Bug fixing

So you are all set with changes @3B in the working branch(br-cherry pick@3).

Next, we will merge these changes to master before cherry-picking @7 for the release.

(This step will not be needed if you are not following Trunk Based Development)

@ 3B Pull the latest code from master @6

It’s important to take the latest code from the master branch and make sure the changes or bug fixes are fine in our working branch (short-lived) before merging it back to the master or trunk.

Once everything is working fine please perform staging and commit

@3B – Stage and commit bug fix file only

Stage your bug fix as shown below,

Commit bug fix to the master branch as shown below,

Once done a pull request can be raised to merge changes to the master branch

Merge your changes to master,

So finally we are @7 with the last commit.

@7 Perform cherry-pick

Performing cherry-pick is a two-step process.

1. Check out the Target Branch where cherry-pick needs to be applied.

git checkout -b R1

2. Do a cherry-pick for a given commit ID. One can pick a commit ID from any branch to any branch

So let’s get the relevant commit ID

As we know @7 the code has been checked into git with a commit ID. So we shall use the same commit hash ID and cherry-pick it as shown below,

The last commit ID is as below from master branch,

Command :

git cherry-pick -x 17784261c69c95649c24c86b52ca35a353e8504e

Changes are successfully applied to the R1 branch,

You are all set with cherry-picking and your bug fix is ready to be pushed to production release (•_•). I hope your code works best !!

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Happy

Picking !!

References:

• Trunk Based Development – Code development Best Practices

• Add Images to Git Read.Me file

Summary

Cherry-pick is a technique of picking up a commit from a branch and applying it to another branch. If used correctly Cherry-pick can address multiple use cases like bug fixing or patching purposes or un-doing the changes. Apart from this cherry-picking could also be useful in code collaboration.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Cherry Pick in Git for Trunk-Based Development first appeared on TheCodeBuzz.