DEV Community: Armando Serna Gutiérrez

How git manages versions of our files

Armando Serna Gutiérrez — Fri, 14 Jan 2022 18:42:44 +0000

Hi everyone 👋

I recently watched a section of the course The Complete Git Guide by Bogdan Stashchuk, where he explains the internals of how git versions our project files and I think it really helped me to understand this tool. So that's why I want to share with you this knowledge in this blog post.

Git commands used in this tutorial

git ls-files -s: List the objects that are on the staging area
git cat-file -p: Get the contents of a git object
git cat-file -t: Get the type of a git object

Diagram of our git repository

Diagram after committing a new file

Object types in git

Before going straight into details on how git saves the version of our files, let's first understand the 4 object types of git:

Blobs: this are like files. A blob is composed by the type of object, the size of the object, a delimiter, and the contents of the file.
Trees: this are like directories. A tree is composed by a list of blobs and trees that the project has.
Commits: the commits are like special snapshot of a repository.
Tags: We will not cover this object type in this post.

Git stores all of this objects in the .git/objects directory of every repository as files compressed in binary format.

How does git version a single file?

Each time we make a commit of some changes on a repository, git automatically creates the necessary blobs, trees and commits to save the version of our files.

To demonstrate you this, Let's create a new git repository.

Now, if we take look into our .git/objects directory, we'll see that there are any objects in the repo. (Ignore the info and pack directories)

Next, to see some objects, let's add a new file and stage the changes.

The action of adding changes to the staging area, created a new blob object. To see this new object we can either run git ls-files -s command.

If we take a closer look to the output of this command we will find that we have hash for this object. This hash serves as a unique identifier for this version of the file, and we actually get can the contents of this file just by appending this hash to the git cat-file -p <hash> command.

Also we can get the type of the object by using the -t flag.

We can even take another look into .git/objects and we'll see a new file and folder has been created for this blob object.

What about trees and commits?

We have seen how git creates a version of the file just by adding a new file to the staging area.

Now, to see how git creates a new tree and associate this to a commit.

To do so we only need to run git commit.

We can see from the output that a new hash for the commit has been created. That means we can use git cat-file -p to examine the contents of this new commit object.

Now we see that git created not only a new object for our repository, but also a new tree. Let's now get the contents of this tree.

There we can see a list of all blobs and trees that has this project version. For now, we can only see one blob object is listed, but as we continue adding more files, we will see more in that list.

It is important to note that every time we make a change to the current state of the project and commit those changes, git will automatically create a new commit and tree with new hashes and may create new blob objects if there were files modified or added.

AWS: How to schedule launch and termination of an EC2 instance

Armando Serna Gutiérrez — Wed, 08 Sep 2021 00:59:51 +0000

A common scenario

After deploying application to an dev/testing server hosted in EC2, you may find that the developers only need access to this servers during their work hours.

So having your instances active during hours that you know the users don't really need access to that servers may represent an unnecessary waste of money.

The solution: Schedule actions on auto-scaling groups.

The solution I'm going show you in this post uses the schedule actions of the auto-scaling groups.

You will see that with this approach you will be able to adjust the Desired Capacity, Minimum Capacity and Maximum Capacity of the group of instances you're working with at certain hours of the day.

For this example the Desired Capacity will be set to 1 instances during work hours, and for inactive hours it will be again adjusted but now to 0 instances.

You can see in the following image the architecture of the solution:

To create this solution you need to follow the next steps.

Create an AMI of the instance
Create a launch template using the AMI created
Add your launch template to a load balancer
Add your launch template to an auto-scaling group
Add an schedule action to scale-up and another to scale-in

Full explanation step by step.

I will explain how to create this solution using the AWS web console. In a later tutorial I will explain how to create this same solution bit using an IaC tool like Terraform.

For this example I created a t2.micro instance and installed an apache web server on it. In the following image you can see the web server is running on port 80.

This instance executes the web server on each startup. This come will come in handy since we will be creating and terminating new instances every day.

Step 1: Create an AMI of the instance

Now using AWS web console, go to the instance of the EC2 service. Right click on the instance you want to work with and choose Create image.

In the next page give a name to your image and click on Create image.

Now if you navigate to the AMI section you will see a new image is created and is on pending status.

Step 2: Create a Launch Template using the AMI created

Navigate to the Launch Template section and click on Create Launch Template.

In the Amazon machine image section search for the name of the image and select it. Also select the Latest version of the image.

Ensure to choose the same security group that your existing instance has.

Click on Create launch template

Step 3: Add your launch template to a load balancer

Select Application Load Balancer

Give a name to the load balancer

Select at least two availability zones

Use the default listener and click on create target group

It will open a new browser tab to create the target group. Give a name and choose Instances for the instance type.

Leave all the other options as default, click next and click on Create target group. Return to the tab of the load balancer creation.

Search for the target group in the default listener and select it.

Click on Create load balancer.

Step 4: Add your launch template to an auto-scaling group

Navigate to the Auto-scaling group section and click on Create auto-scaling group.

Give a name to the Auto-scaling group and choose the launch template we have created. Click on next.

Select the two Availability zones we choose on the creation of the load balancer. Click on next.

In the next section choose Attach to an existing load balancer and select the load balancer we created in the previous step. Click on next.

For the group size I will set the values as showed in the image. Click on next.

For Add notification and Add tags just click next. To finish, click Create auto scaling group.

Step 5: Add an schedule action to scale-up and another to scale-in

Navigate to the Load balancers section, select the recently created load balancers from the list, and click on the Automatic scaling tab.

Scroll down until you see schedule actions. Click on Create scheduled action

Give a name, set desired capacity to 1, for recurrence choose Cron, enter this cron expression 0 8 * * MON-FRI, choose your timezone and select the start time of your action.

This configuration will set the desired capacity to 1 from monday to friday at 8 am.

Now to scale-in create another schedule action but now setting the desired capacity to 0.

Terminate the existing instance

As this solution uses an image to launch new instances you can terminate the existing one and wait until the scale-out action get executed to see a new instance.

Accessing the application

To access the application use the DNS name of the application load balancer.

GIT: How to commit only parts of a file?

Armando Serna Gutiérrez — Sat, 04 Sep 2021 18:30:20 +0000

Scenario

It probably happened to you that after making lots of changes to some code files, you see one of those changes is ready so you decide to commit only this single change (maybe because you want to share it with other colleagues or maybe the client is asking to have this change ready).

So you open your terminal and run the git diff command on the file where your change is and see the following output:

And there it is, the part of the file you want to commit is the where the line font-weight: normal; is added. But there is also another change in this file.

So using git add style.css isn't an option for this scenario, as it would be introducing two different changes into the commit I want to share.

The solution: the --patch argument

So the solution to this usual scenario (it has happened to me a million times) is adding the argument --patch to the git add command.

Doing this will prompt us for each change (or hunk) we have in our file if it should be part of our changes to be committed.

So after running git restore style.css --staged to restore our previously staged changes, we run git add style.css --patch and see the following output:

And as you can see, now git is asking us if the line that contains the change to the background should be included or not.

We can input y for yes or n for no, or simply input a ? to get a description of each option.

So we decided to not include the first hunk and then include the second one as we can see in the image below:

Then if we inspect our staged changes there's only the changes we want.

Why would I ever want to commit one part of the file?

In git there is a concept called "atomic commits", which are commits that only contains a single logical change to a part of the code.

Using atomic commits makes our repositories easy to navigate and to inspect, and has a lot of benefits for teams that needs to review older parts of the code in order to fix a bug for example.