gitflow | Git extensions to provide

Then you have to add them to a group and number the entries

Commonly "master" or "main" is pushed to prod as it's a form of a "stable" release. though this also depends on the type of project/where its used type of deal, internally a company will use the method above, but as an open-source repo it is common for a release to be used instead.

In my own development experience, a base repo will be created. Developers will make branches for features, hotfixes, etc... etc... and then put a PR into a staging environment which once stable and passes unit tests (via CI/CD) will be deployed.

Unsure if this helps much, but is what I think when this question is brought up.

With Git (and even more with Git + Github) you have a lot of possible workflows for team-based developments, you have to define applicable and usable for your team: everybody have own habits and mileage may|have vary

You can:

• Use single repo or forks
• Use personal repo and add collaborators to it or have "organization" + "org. repo" + "org. members"
• Use PR (pure GitHub specific) or enable just merge branches
• Use GitFlow or GitHubFlow or Trunk-based develpment or ...

Git is decentralized. Each developer has their own complete copy of the repository but in order to share code with others you need to sync your changes with a central "origin". GitLab is your "origin".

Gitflow is about creating a feature branch off of develop and merging it back. But in a distributed model we enhance gitflow by creating a pull-request to merge our feature branches back into develop.

The recommended flow:

1. clone the repository
2. switch to the develop branch
3. create a feature branch off of develop
4. push your feature branch to origin
5. use gitlab to create pull-request for your code
6. after the pr is completed, switch your local branch to develop
7. pull the latest from origin
8. delete the local feature branch

repeat 3-8 endlessly.

If you want others to work on your feature, start by cloning the repository. You only need to do this once.

1. get the latest changes from gitlab: git fetch
2. switch your branch to the feature branch: git checkout feature/x
3. use git add / commit / push to update origin with your changes
4. use git pull to fetch their changes to your machine.

Your best approach is to switch to YAML builds and releases. That way your pipeline is versioned together with the code.

If you don't do that, you may need to clone your build and releases every time you make breaking changes.

Alternatively, use the version diff view in your pipeline to go back to an older version or use the json to create a new definition using the API.

Upgrading to Azure DevOps Servers 2020 will give you more advanced YAML features not yet available in Team Foundation Server 2018.

Note: for truly reproducible builds, you'll need to also find a way to lock the build tasks themselves, TFS and Azure DevOps will automatically roll forward to the latest minor version of a given build task. While task authors should try to prevent any breaking changes in those minor upgrades there are no guarantees. You can also never rely on any tool installers that use a v2.x notation or a task that relies on latest. Azure DevOps isn't ideally suited for full reproducible builds.

You can pin task versions in YAML now, if I remember correctly, this was added in Azure DevOps 2020.

You can set which minor version gets used by specifying the full version number of a task after the @ sign (example: GoTool@0.3.1). You can only use task versions that exist for your organization.

See: https://docs.microsoft.com/en-us/azure/devops/pipelines/process/tasks?view=azure-devops&tabs=yaml#task-versions

The Tasks docs offer special scripts to pin the versions of out-of-the-box tasks as well.

First things first, Lambda and S3 need to be in the same region.

Secondly, it looks like you're not the bucket owner (you haven't created the bucket yourself by looking at the template).

This means, the bucket you're using to retrieve the Lambda source code from is (I suppose coming from the workshop), and they decided to create that bucket in the region us-east-1. Enforcing you to also deploy your stack in the region us-east-1 (if you want to follow the workshop).

But what if you really wanted to deploy this stack to eu-west-1?

That would mean you need to create a bucket in region eu-west-1 with and copy the objects from the workshop bucket into your newly created bucket and update your CloudFormation template to point and retrive the Lambda source code from your newly created bucket (note you might need to name the bucket differently as bucket names are globally shared).

I hope this is a bit clear.

Although I've been using the Git Flow branching strategy for years, I confess I've never used the git flow commands before, but I just tested them out and can confirm what you're witnessing, though some clarifications are in order.

As best I can tell, you aren't ever prompted to write a commit message for any of the merge commits. However, when you finish a hotfix or release branch, you are prompted to write the Tag message, which happens to also be included in the merge commit message details (below the commit title), so it may look like you were writing the merge commit message. Since only releases and hotfixes are tagged, this is why you aren't prompted with an editor when you finish feature branches.

Regarding the --no-ff merges, the following rules are in place:

1. When finishing a release or hotfix branch, the merge is always performed with the --no-ff flag.
2. When finishing a feature branch that has 2 or more new commits, the merge is performed with the --no-ff flag.
3. When finishing a feature branch that has exactly 1 new commit, the merge is performed with the --ff flag (which is also the default for merge).

Note that using -ff in the third rule means it will do a fast-forward if possible, meaning the merge commit is sometimes avoided, which is interesting because AFAIK this isn't suggested anywhere in the Git Flow documentation. It does make sense though since there is no information gain from forcing a merge commit when you only have a single commit to merge in. It still stays true to the --first-parent view of the develop branch showing all completed feature branches.

Side Note: when I personally use Git Flow, I always force the merge commit even for single commit merges, because I put additional PR information in the customized merge commit messages. This is one of the reasons I don't use the git flow commands. (Besides, our SCM tool handles the merges of completed Pull Requests anyway, so no one would "finish" anything themselves.)

Let's break apart your question into two parts:

how can I go back in time, [to] produce a fix for an older version ?

Your question mark in your second diagram is exactly right for this. Simply find the tag of the release you wish to modify, branch off of it (perhaps naming it something like hotfix/1.1.1), and commit your new changes. Then tag that "release".

For your second half of the question:

how can I ... merge it back in the trunk ?

And especially what if:

I do not want that fix to be brought back in the trunk ?

If you do wish to integrate that hotfix into trunk, it's easy- just merge it in (and if you have conflicts resolve them as you normally would).

If you don't wish to integrate that hotfix into trunk, you have some options:

1. Keep your hotfix/1.1.1 around indefinitely. Branches are super cheap and this is a valid strategy that many companies use. (In fact many companies do away with the master branch altogether in a Git-Flow-Like strategy and just keep their release/ branches around indefinitely.) If you go this route you might someday have many remote branches, in which case I would recommend using the pseudo directory slash character (/) in your branch name as suggested with hotfix/1.1.1. Many Git clients enable you to roll up your branches by pseudo directory so you don't have to look at hundreds of branches that don't interest you (by collapsing the hotfix/ directory in the view.)
2. My personal preference is not to keep lots of hotfix branches around forever, so instead you can get a little fancy and merge the hotfix branch back into trunk, but tell Git to ignore the change. After doing this you can delete the hotfix branch since all the information is contained in the new tagged commit in trunk.

Here's how to merge a branch without taking the changes:

Creating an annotated tag in Git is simple. The easiest way is to specify -a when you run the tag command: