Forem: Rishav Sinha

Terraform Basic Command

Rishav Sinha — Fri, 04 Feb 2022 18:49:43 +0000

What Exactly is Terraform IaC?

Terraform is an open-source infrastructure as code software tool that enables you to safely and predictably create, change, and improve infrastructure.

This is the definition that Hashicorp (Company working on Terraform) uses.

But in simple terms Terraform is used as IaC to create , change and imporve resources provided on different cloud services with simply writing code that is it.

Now let's understand this by a simple example.
Suppose your company wants you to deploy a web app using some instances , a provisioned Database, some cloud functions etc.
So traditionally you will go to cloud console (take AWS as example cause why not 😁) and enable services by order like creating the instance, using DB services and lamada's etc.

This takes time and is pretty cumbersome to debug as we can miss step.

So using IaC services such as Terraform we can simply write code to use the above said services and all the services will be deployed automatically, not only deploy if we want to delete or change some we can simply use the code for that.
Trust me it very Simple and remove too many bottlenecks.

So this is what Terraform is and it uses in a nutshell.

Cool 😎 😎 now lets see some of the commands which are generally used and you will probably use regularly while working with Terraform

Prerequisite

Before starting make sure you have terraform installed using the following command

terraform --version

Now after verified that you have Terraform installed, create a new directory and create a file main.tf this will host our first terraform code

In that file put the code snippet, This snippet leverages the random provider, by HashiCorp registry, to generate a random string put name. Inside that we have optional parameters such as length. Here we're using random , if we're using some cloud service we will use that here like instances, db recourses etc.

resource "random_pet" "random" {
 length = 6
}

*## * LETS GET GOING WITH COMMANDS
*

1. init

init is quite similar to git init, basically initializing a new terraform workspace.

After that terraform will communicate with the registry and fetch all the necessary resources metadata in this case the random provider

As soon as this process completes you will see some changes in your folder structure.

2. validate

validate validates the configuration files in your workspace in our case ie main.tf.

If we have some syntax issue it will show up. See I have changed a resource parameter which is not valid. Running it again

3. plan

Now before making some actual changes to your infrastructure , we can "dry run" or check if every resource we specified in the configuration file is correct.

4. apply

It is used to build the resources you planned for from your config file i.e. main.tf

It will spit out the following output, we can put yes to move further, terraform will built your random string resource based on
what was in your plan file.

Also you will see the output as well marked in the image in our case the pet name

4. destroy

destroy as the name says destroy command is a easiest way to destroy all resource mentioned in the configuration. It does not delete your configuration file(s), main.tf, etc.

That's it folks, these are the basis and the most used Terraform commands, Please heart ❤️ if you like the content, will publish few more with some real life examples.

❄️

Dockerfile Teardown

Rishav Sinha — Wed, 11 Nov 2020 16:07:59 +0000

So your app is ready, and now you want to containerize it using docker.If yes,then read on.

Docker file is a file which contains all commands that are required to generate an image.

Simple Docker file

Creating a Docker file.

In your project directory create a new file with the exact name Dockerfile.

Inside this file only we will have all the commands listed.Lets see what are those commands.

1. FROM

FROM <image>:<tag>

Dockerfile must start with FROM. This basically sets the base image.

# Example

FROM node:13-alpine

Instructed to get the base image of node with version 13.

2. LABEL

LABEL <key><value> <key2><value2>

Used to set metadata for the image.It is a key-value pair

# Example

LABEL companyname="xyz organization"

Sets companyname label.You can access it using docker inspect

3. RUN

RUN <command>

Executes command inside the new image and commits the results.

# Example

RUN mkdir -p /home/app

This will create a new directory inside the image

3. CMD

CMD [<command>,<command>]

The first commands to be executed after container is created.

# Example

CMD ["npm", "start"]

This will execute npm start when container is created.

4. EXPOSE

EXPOSE <port>

Informs Docker that the container listens on the specified network ports.This information is used to interconnect containers using links and to set up port redirection on the host system

# Example

EXPOSE 3000

This will expose port inside the container as well as for host machine.

5. ENV

ENV <key><value>

Sets environment variables to the value .This is passed to all RUN , CMD instructions

# Example

ENV MONGO_DB_USERNAME=admin

Here MONGO_DB_USERNAME env is set to admin

6. COPY

COPY <source> <destination>

Copies files from source i.e the host into image.All new files & directories are created with mode 0755.

# Example

COPY ./package.json /home/app

Here package.json file is being copied from current directory to /home/app in image.

7. ADD

ADD <source> <destination>

Same as copy but some slight change.

The ADD instruction can copy and extract TAR files from the Docker host to the Docker image.

# Example

ADD unzipthis.tar /home/app

This will extract files inside the image to the specified directory.

8. VOLUME

VOLUME <path>

Used for persistence inside docker images.This instruction can create a directory inside the docker image, which can later be mounted to a directory

# Example

VOLUME /data

9. WORKDIR

WORKDIR <path>

Instruction specifies what the working directory should be inside the Docker image

# Example

WORKDIR /home/app

This will the directory where the RUN or other instruction will be executed.

Now try Reading this dockerfile again

Hope this will make writing Dockerfile easier for you.