git-rev | git revision in node | Runtime Evironment library

You have:

If your goal is to keep secret values out of the statefile, then you have two choices:

1. Encrypt the secret outside of Terraform, then store the encrypted value in Secrets Manager.

   This will force all consumers of the secret to decrypt it before use. Since an encrypted secret includes the CMK used to encrypt it, there's no need for you to separately track the key ID.

   There are several drawbacks to this approach. For one thing, you have to do two steps to use any secret: retrieve it and decrypt it. If you use ECS, you can't provide the name of the secret and let ECS to provide the decrypted value to your container.

   A bigger drawback is that it can be very easy to forget which CMK is used for which secret, and accidentally delete the CMK (at which point the secret becomes unusable). Related is knowing which permissions to grant to the consumers, especially if you have a lot of CMKs.

2. Create the secret inside Terraform, and set its value manually.

   This keeps the actual value in Secrets Manager, so you don't need to use two steps to decrypt it.

   It is possible to use local-exec to generate the secret within the Terraform configuration: write a script that generates random data and then invokes the AWS CLI to store the value. However, this technique is more frequently used for things like SSH private keys that are created outside of the Terraform provisioning process.

Better than either of these solutions is to store your statefile somewhere that it isn't generally accessible. There are a bunch of backends that can do this for you.

Adding ENV LC_ALL=C to Dockerfile solving the issue

Could be many things, you're very likely to find the answer here. (Posted as answer because I don't have enough rep yet for commenting)

Warning: this answer is quite long, and there's no TL;DR at the top.

I'm not completely sure what you're asking here, especially in this part:

Also is there a way to not show these ~ and ^ when making a tag?

When you make a tag, you choose the name yourself. You cannot embed the ~ and ^ characters in the name you choose—see rule 4 in the check-ref-format documentation—so they will never be part of any tag.

The git name-rev command adds ~ and ^ characters to existing, valid names when borrowing them, but only when that's necessary. To understand what's going on here, you need to understand a little bit of graph theory, and that Git's commits form a Directed Acyclic Graph or DAG.

... does tag/version-0.8.7~2 means two committed changes before tag/version-0.8.7?

Sort of. It's a good idea to ditch the phrase "two committed changes", though. Git's commits are not changes. A commit represents a complete snapshot of all files.

Each commit, in a Git repository, is a real, actual thing: something solid, as it were, that you can take out and examine. Think of them as marbles in a bag, or bricks in a building, or whatever other analogy you like. If you use the "bricks in a building" analogy, then it's true that the building (the whole collection) is not a brick, and just having a brick won't get you the building—but at the same time, each brick is a real thing. It's not an abstract concept (though the concept itself certainly exists; you can imagine a "perfect brick", if you like, with no flaws or imperfections, but you'll never find an actual brick with no flaws: see Plato's Theory of Forms). If you take a real brick out of the building, it's something solid, and you can whack someone in the head with it. (Ow! Quit that! 😀) With that in mind, let's note that any given repository is largely made up of the commits that are in that repository, in much the same way that the Puni Distillery in Glorenza, Italy is made up of those specific bricks, in their specific arrangement. (I've never tried Puni whisky, but this looks like an interesting place to visit!) You can't just pile any old bricks (or commits) up randomly; you need these ones, in this specific arrangement.

Going back to commits in a Git repository, let's consider what makes a commit a commit. Each commit in the repository is unique, and each one has a unique number, that lets Git find that commit. So we know that every commit is numbered. These commit numbers are hash IDs, the big ugly strings that look like 3cf59784d42c4152a0b3de7bb7a75d0071e5f878, for instance. What you might not know—not all Git tutorials make this clear—is that every commit holds a full snapshot of every file.

To make this work well, Git stores the files in a special, read-only, compressed, Git-only, frozen-for-all-time, and de-duplicated format. So if you make a bunch of commits in a row, and most of those commits mostly re-use the same files as previous commits, most of those commits take almost no space because the files are literally re-used. Only files that are unique to this particular commit have to store a new copy. (Note that this technique kind of falls apart if you store, say, 5 GiB DVD images. Every slightly-different DVD image requires another 5 GiB. If you're storing text files, and you have tens of thousands of those files and change one, you're changing just one small file—something that's maybe a few kiB or MiB at most—and re-using all the others while storing one new 5 kiB or even 5 MiB file is easy, compared to storing one new 5 GiB file.)

Besides the files—which are usually the main data of a commit—each commit also stores some metadata, or information about the commit itself. This includes the name of the person who made the commit. It includes a date-and-time-stamp, showing when they made the commit. It includes their commit message. But it also includes one key item that Git wants for Git: Git stores, in the commit, the commit number—the hash ID—of some set of previous commits used to build up the repository-so-far. Most commits only need one previous-commit hash ID, and that's what we'll look at first.

The thing to take away from the above is this:

• Each commit is numbered, using a hash ID. This is literally how Git finds commits, by the numbers.

• Each commit has two parts: it's a snapshot of all of the files Git knew about at the time you (or whoever) made the commit, plus some metadata about the commit, including who made it, plus information about where the commit goes in the history.

The history information, which is part of each commit, is simply a link—a pointer, if you will—to some set of previous commits.

Mathematically, a graph is just a collection of vertices (sometimes called nodes) and edges: connections from one vertex to another. If the edges have a directional arrow, mathematicians and computer scientists tend to call them arcs instead of edges. We'll just start by drawing them using arrows.

In Git, the simplest kind of graph is a straight line. We have some series of commits, starting with the very first one we ever made in some repository, and ending with the most recent one. Each one has a unique—and random-looking—hash ID, but to keep ourselves sane, we'll draw these commits using sequential uppercase letters, like this:

The reset should have worked, but on master, resetting to e:

After the merge:

Kinda slow and not ideal but you can do something like this:

Git is a tool-set, not a solution, so there are multiple solutions. However, one relatively straightforward way is to start with git revert -n, which starts the revert but does not finish it:

Looks like currently there's no proper documentation out there that can serve your purpose.

So, in order to get your concern ( and similar concerns of others ) addressed, the only place (as of now) you can go to is the code base itself and find out ( which in itself is another question for beginners, as to how to navigate the source code and dig deeper just to find the allowed expressions/values/codes buried somewhere deep in the source code ), additionally learn some C/perl/bash/python and other things just to understand the source code.

Long story short, this-thing-here can help you.