DEV Community: codebrewster

Introduction to Vim and how to start using it

codebrewster — Thu, 29 Dec 2022 17:24:20 +0000

introduction

Hi there! If you're a developer or programmer, you know how important it is to have the right tools at your disposal. That's where Vim comes in – this awesome text editor is used by professionals all over the world and is known for its speed and efficiency. I started using Vim a few years ago, and it has completely changed the way I work. It may seem a bit intimidating at first, but once you get the hang of it, you'll wonder how you ever lived without it. In this blog, I'm going to introduce you to Vim and give you some tips on how to start using it like a pro. Whether you're a complete beginner or an experienced developer, there's something here for you. So, let's get started!

diving in:

So, how can you start using Vim and get the most out of it? Here are a few tips to get you started:

Learn the basic commands: Vim has a number of basic commands that you'll need to know in order to edit text and navigate through files. Some of the most important ones include "i" for insert mode, "Esc" to return to normal mode, and ":w" to save a file. You can find a complete list of Vim commands at https://www.vim.org/docs.php. It's a good idea to spend some time familiarizing yourself with these commands, as they will form the foundation of your Vim skills.
Practice using Vim: The best way to get good at using Vim is to practice using it. You can start by simply opening Vim and playing around with the various commands, or you can try working on a real project. The more you use Vim, the more comfortable you'll become with it. As you become more comfortable with Vim, you can start exploring more advanced features such as macros, splits, and buffers.
Customize Vim to suit your needs: Vim is highly customizable, and you can modify it to suit your specific needs and preferences. For example, you can create custom key bindings, change the color scheme, and add plugins to extend the functionality of Vim. Customizing Vim to suit your needs can make it more efficient and enjoyable to use.
Take advantage of online resources: There are many online resources available that can help you learn Vim and become proficient with it. Some good ones to check out include the Vim documentation, the Vim Tips Wiki, and various Vim-related blogs and forums. These resources can provide you with helpful tips, tricks, and advice on how to use Vim effectively.

few more basic commands:

"h", "j", "k", "l" - These keys move the cursor left, down, up, and right, respectively.
"dd" - Deletes the current line.
"yy" - Copies the current line.
"p" - Pastes the copied or deleted text after the cursor.
"u" - Undo the last change.
"Ctrl+r" - Redo the last change.
"gg" - Move to the top of the file.
"G" - Move to the bottom of the file.
"w" - Move to the beginning of the next word.
"e" - Move to the end of the current word.
"b" - Move to the beginning of the current word.

These are just a few examples of the many commands available in Vim. As you continue to use and learn Vim, you'll become familiar with more and more commands, and you'll be able to use them to edit and navigate through text more efficiently.

Using Terraform to create a bucket with versioning enabled (extra: an easy to use script)

codebrewster — Tue, 06 Dec 2022 15:50:20 +0000

Introduction

Amazon Simple Storage Service (S3) is a popular cloud storage solution that offers scalable, high-speed, and low-cost storage. In this blog, we will demonstrate how to use Terraform to set up an S3 bucket and enable versioning for it.

Prerequisites:

First, make sure that you have the following prerequisites:

Terraform installed on your system. If you don't have it, you can download it from https://www.terraform.io/downloads.html
An AWS account. If you don't have one, you can create one at https://aws.amazon.com/
AWS access keys. You can create these by following the instructions at https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys
Once you have these prerequisites, follow these steps to set up an S3 bucket using Terraform and enable versioning for it:

Steps:

Create a new directory for your Terraform project and navigate to it.

mkdir s3-bucket-terraform
cd s3-bucket-terraform

Initialise Terraform in the current directory by running the following command:

terraform init

Create a file named main.tf in the current directory and add the following code to it. This code defines the S3 bucket that we will create using Terraform.

resource "aws_s3_bucket" "my-bucket" {
  bucket = "my-bucket-name"
  acl    = "private"

  versioning {
    enabled = true
  }
}

In this code, we use the aws_s3_bucket resource to create an S3 bucket named my-bucket-name with the private access control list (ACL). We also enable versioning for this bucket by setting the enabled property of the versioning block to true.

Set the AWS access keys as environment variables by running the following commands:

export AWS_ACCESS_KEY_ID="your-access-key-id"
export AWS_SECRET_ACCESS_KEY="your-secret-access-key"

Run the following command to apply the changes defined in the Terraform code and create the S3 bucket:

terraform apply

This command will prompt you to confirm the changes. Type yes and press Enter to continue. Terraform will then create the S3 bucket and enable versioning for it.

After the bucket is created, you can verify that it has been created and that versioning is enabled for it by going to the S3 section of the AWS Management Console and checking the list of S3 buckets. You should see the my-bucket-name bucket in the list, and if you click on it, you should see the versioning information in the Properties tab.

Congratulations! You have successfully set up an S3 bucket using Terraform and enabled versioning for it. This will allow you to store multiple versions of an object in your S3 bucket and easily recover earlier versions if needed.

Extra:

The following shell script can be used to set up an S3 bucket using Terraform and enable versioning for it. This script takes the bucket name as an argument, so you can use it to create multiple S3 buckets with different names. Before running this script, make sure that you have the prerequisites mentioned in the previous answer, such as Terraform and AWS access keys.

#!/bin/bash

# check if a bucket name was provided as an argument
if [ $# -eq 0 ]; then
  echo "Error: No bucket name provided. Usage: ./setup-s3-bucket.sh <bucket-name>"
  exit 1
fi

# create a new directory for the Terraform project
mkdir s3-bucket-terraform
cd s3-bucket-terraform

# initialize Terraform in the current directory
terraform init

# create a file named main.tf in the current directory and add the following code to it
cat << EOF > main.tf
resource "aws_s3_bucket" "my-bucket" {
  bucket = "$1"
  acl    = "private"

  versioning {
    enabled = true
  }
}
EOF

# set the AWS access keys as environment variables
export AWS_ACCESS_KEY_ID="your-access-key-id"
export AWS_SECRET_ACCESS_KEY="your-secret-access-key"

# apply the changes defined in the Terraform code and create the S3 bucket
terraform apply

To run this script, save it to a file, such as setup-s3-bucket.sh, and make it executable using the following command:

chmod +x setup-s3-bucket.sh

Then, run the script and provide the bucket name as an argument, like this:

./setup-s3-bucket.sh my-bucket-name

The script will create the S3 bucket and enable versioning for it. You can verify this by going to the S3 section of the AWS Management Console and checking the list of S3 buckets. You should see the my-bucket-name bucket in the list, and if you click on it, you should see the versioning information in the Properties tab.

You can run the script multiple times with different bucket names to create multiple S3 buckets. For example:

./setup-s3-bucket.sh my-bucket-name-1
./setup-s3-bucket.sh my-bucket-name-2

This will create two S3 buckets named my-bucket-name-1 and my-bucket-name-2, respectively, and enable versioning for both of them.

Thanks :)

If this blog helped you in any way, follow me on twitter for more such stuff (https://twitter.com/_jumpingcats)

Setup basic SaaS infrastructure using Terraform

codebrewster — Sun, 04 Dec 2022 15:48:52 +0000

Introduction

In this tutorial, we will be using Terraform to setup the infrastructure for a SaaS company from scratch. We will be using various AWS resources including S3 buckets, ACM Certificate, Route53 entries, VPC, EC2 instances, CloudWatch, Lambdas, RDS, and API Gateways.

Prerequisites

AWS Account
Terraform installed on your system
AWS CLI configured on your system

Getting Started

Before we start, let's create a new Terraform project and initialize it. Create a new directory and change your current directory to it.

mkdir my-saas-company
cd my-saas-company

Now, run the following command to initialize the Terraform project.

terraform init
This will download the required plugins for the AWS provider.

Setup S3 Buckets

We will start by setting up four S3 buckets for hosting our SaaS company's website and other data. Add the following code to a file named s3.tf.

resource "aws_s3_bucket" "hosting" {
  count          = 4
  bucket         = "my-saas-company-${count.index+1}"
  acl            = "public-read"
  force_destroy  = true
}

This code will create four S3 buckets with names my-saas-company-1, my-saas-company-2, my-saas-company-3, and my-saas-company-4. The count and count.index+1 variables are used to create multiple resources with different names. The force_destroy attribute is used to ensure that the S3 bucket is deleted along with all its contents when the Terraform project is destroyed.

Setup ACM Certificate

Next, we will create an ACM (AWS Certificate Manager) certificate for our domain. Add the following code to the same s3.tf file.

resource "aws_acm_certificate" "certificate" {
  domain_name       = "my-saas-company.com"
  validation_method = "DNS"

  tags = {
    Name = "my-saas-company-certificate"
  }
}

This code will create an ACM certificate for the domain my-saas-company.com using DNS validation. You can also add tags to the certificate for easier identification and management.

Setup Route53 Entries

Next, we will setup Route53 entries for our domain and S3 buckets. Add the following code to the s3.tf file.

resource "aws_route53_record" "website" {
  count       = 4
  zone_id     = aws_route53_zone.primary.zone_id
  name        = "my-saas-company-${count.index+1}.my-saas-company.com"
  type        = "A"
  alias {
    name                   = aws_s3_bucket.hosting.*.website_endpoint[count.index]
    zone_id                = aws_s3_bucket.hosting.*.hosted_zone_id[count.index]
    evaluate_target_health = true
   }
}

resource "aws_route53_zone" "primary" {
   name = "my-saas-company.com"
}

This code will create four Route53 entries, one for each of our S3 buckets. The aws_route53_zone resource is used to create a new zone for our domain. The aws_route53_record resource is then used to create four A-type records for the subdomains of our S3 buckets. The alias attribute is used to link these records to our S3 buckets.

Setup VPC

Next, we will setup a VPC (Virtual Private Cloud) for our EC2 instances. Add the following code to a new file named vpc.tf.

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "my-saas-company-vpc"
  }
}

This code will create a VPC with a CIDR block of 10.0.0.0/16. You can also add tags to the VPC for easier identification and management.

Setup EC2 Instances

Next, we will create EC2 instances for our workers and development environment. Add the following code to the vpc.tf file.

resource "aws_instance" "worker" {
   count = 2
   ami = "ami-0c55b159cbfafe1f0"
   instance_type = "t2.micro"
   vpc_security_group_ids = [aws_security_group.instance.id]
   tags = {
      Name = "my-saas-company-worker-${count.index+1}"
   }
}

resource "aws_instance" "dev" {
   ami = "ami-0c55b159cbfafe1f0"
   instance_type = "t2.micro"
   vpc_security_group_ids = [aws_security_group.instance.id]

   tags = {
      Name = "my-saas-company-dev"
   }
}

resource "aws_security_group" "instance" {
   name = "my-saas-company-instance"
   description = "Security group for EC2 instances"
   vpc_id = aws_vpc.main.id

   ingress {
      from_port = 0
      to_port = 0
      protocol = "-1"
      cidr_blocks = ["0.0.0.0/0"]
   }

   egress {
      from_port = 0
      to_port = 0
      protocol = "-1"
      cidr_blocks = ["0.0.0.0/0"]
   }

   tags = {
      Name = "my-saas-company-instance"
   }
}

This code will create two worker instances and one development instance. The AMI used in this example is the latest Amazon Linux AMI. You can choose any AMI that suits your needs. The aws_security_group resource is used to create a security group for our instances that allows all traffic.

Setup CloudWatch Logging

CloudWatch is a useful tool for monitoring and logging the performance and health of your AWS resources. We will setup CloudWatch logging for our EC2 instances. Add the following code to the vpc.tf file.

resource "aws_cloudwatch_log_group" "instance" {
  name              = "my-saas-company-instance"
  retention_in_days = 14

  tags = {
    Name = "my-saas-company-instance"
  }
}

resource "aws_cloudwatch_log_stream" "instance" {
  count             = 2
  name              = "my-saas-company-worker-${count.index+1}"
  log_group_name    = aws_cloudwatch_log_group.instance.name

  tags = {
    Name = "my-saas-company-worker-${count.index+1}"
  }
}

resource "aws_cloudwatch_log_stream" "dev" {
  name              = "my-saas-company-dev"
  log_group_name    = aws_cloudwatch_log_group.instance.name

  tags = {
    Name = "my-saas-company-dev"
  }
}

resource "aws_cloudwatch_log_metric_filter" "instance" {
  count             = 2
  name              = "my-saas-company-worker-${count.index+1}"
  pattern           = "[...]"
  log_group_name    = aws_cloudwatch_log_group.instance.name
  metric_transformation {
    name              = "my-saas-company-worker-${count.index+1}"
    namespace         = "my-saas-company"
    value             = "1"
    default_value     = "0"
  }

  tags = {
    Name = "my-saas-company-worker-${count.index+1}"
  }
}

resource "aws_cloudwatch_log_metric_filter" "dev" {
  name              = "my-saas-company-dev"
  pattern           = "[...]"
  log_group_name    = aws_cloudwatch_log_group.instance.name
  metric_transformation {
    name              = "my-saas-company-dev"
    namespace         = "my-saas-company"
    value             = "1"
    default_value     = "0"
  }

  tags = {
    Name = "my-saas-company-dev"
  }
}

This code will create a CloudWatch log group and streams for our EC2 instances. It will also create metric filters that can be used to monitor specific log events. You can specify a custom pattern for the metric filters to filter out the logs that you are interested in.

Setup Lambdas

Lambdas are a useful tool for running code without the need to provision or manage servers. We will create two Lambdas for our SaaS company. Add the following code to a new file named lambda.tf.

resource "aws_lambda_function" "function" {
  count             = 2
  filename          = "lambda_function.zip"
  function_name     = "my-saas-company-lambda-${count.index+1}"
role = aws_iam_role.lambda.arn
handler = "index.handler"
runtime = "nodejs8.10"

   tags = {
      Name = "my-saas-company-lambda-${count.index+1}"
   }
}

resource "aws_iam_role" "lambda" {
   name = "my-saas-company-lambda"

   assume_role_policy = <<EOF
      {
         "Version": "2012-10-17",
         "Statement": [
            {
               "Action": "sts:AssumeRole",
               "Principal": {
                  "Service": "lambda.amazonaws.com"
               },
               "Effect": "Allow",
               "Sid": ""
            }
         ]
      }
   EOF
}

resource "aws_iam_policy" "lambda" {
   name = "my-saas-company-lambda"

   policy = <<EOF
   {
      "Version": "2012-10-17",
      "Statement": [
         {
            "Action": [
               "logs:CreateLogGroup",
               "logs:CreateLogStream",
               "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:::*",
            "Effect": "Allow"
         }
      ]
   }
   EOF
}

resource "aws_iam_policy_attachment" "lambda" {
   name = "my-saas-company-lambda"
   roles = [aws_iam_role.lambda.name]
   policy_arn = aws_iam_policy.lambda.arn
}

This code will create two Lambda functions and the required IAM role and policy for them. The Lambda functions can be triggered by different events such as an S3 bucket event, an API Gateway event, or a custom event.

Setup RDS

Next, we will create three RDS (Relational Database Service) instances for our SaaS company. Add the following code to a new file named rds.tf.

resource "aws_db_instance" "database" {
   count = 3
   allocated_storage = 10
   storage_type = "gp2"
   engine = "mysql"
   engine_version = "5.7"
   instance_class = "db.t2.micro"
   name = "my-saas-company-database-${count.index+1}"
   username = "my-saas-company"
   password = "my-saas-company-password"
   vpc_security_group_ids = [aws_security_group.rds.id]

   tags = {
      Name = "my-saas-company-database-${count.index+1}"
   }
}

resource "aws_security_group" "rds" {
   name = "my-saas-company-rds"
   description = "Security group for RDS instances"
   vpc_id = aws_vpc.main.id

   ingress {
      from_port = 3306
      to_port = 3306
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
   }

   egress {
      from_port = 0
      to_port = 0
      protocol = "-1"
      cidr_blocks = ["0.0.0.0/0"]
   }

   tags = {
      Name = "my-saas-company-rds"
   }
}

This code will create three RDS instances for the MySQL database engine. The RDS instances are secured using a security group that only allows traffic on the default MySQL port (3306) from any IP address. You can customize this security group to only allow traffic from specific IP addresses or VPCs.

Setup API Gateways

API Gateways are useful for creating and managing APIs for web and mobile applications. We will create three API Gateways for our SaaS company, one for production, one for staging, and one for development. Add the following code to a new file named api-gateway.tf.

resource "aws_api_gateway_rest_api" "prod" {
   name = "my-saas-company-prod"
   description = "API Gateway for production environment"

   tags = {
       Name = "my-saas-company-prod"
   }
}

resource "aws_api_gateway_rest_api" "staging" {
   name = "my--saas-company-staging"
   description = "API Gateway for staging environment"

   tags = {
      Name = "my-saas-company-staging"
   }
}

resource "aws_api_gateway_rest_api" "dev" {
   name = "my-saas-company-dev"
   description = "API Gateway for development environment"

   tags = {
      Name = "my-saas-company-dev"
   }
}

This code will create three API Gateway REST APIs, one for each environment. You can then create and manage different API resources, methods, and integrations for these APIs-.

Conclusion

In this tutorial, we have seen how to use Terraform to setup the infrastructure for a SaaS company from scratch. We have created various AWS resources including S3 buckets, ACM Certificate, Route53 entries, VPC, EC2 instances, CloudWatch logging, Lambdas, RDS, and API Gateways. You can further customize this infrastructure to suit your specific needs and requirements.