AWS , GCP , Azure & Terraform Ec2-instance Launch

Understanding Cloud Concepts

AWS EC2: Provides scalable virtual servers (instances) in Amazon's data centers.
AWS Elastic Cloud (EC): Refers to the collection of AWS services, including EC2, that enable cloud computing.
GCP: Google Cloud Platform offers similar virtual machine instances and cloud services.
Azure: Microsoft's cloud platform also provides virtual machines and related cloud services.
Terraform: An infrastructure as code tool for provisioning and managing cloud resources across various providers.

AWS EC2 Blog Setup

Create an AWS Account: Visit the AWS website and sign up for an account. Follow the instructions to set up your account and provide necessary payment information.
Launch an EC2 Instance
- Log in to the AWS Management Console.
- Navigate to the EC2 dashboard and click on "Launch Instance".
- Choose an Amazon Machine Image (AMI), such as Ubuntu or Amazon Linux.
- Select an instance type based on your requirements, considering factors like CPU, memory, and storage.
- Configure instance details including the number of instances, network settings, and storage options.
- Add tags to identify your instance.
- Configure security groups to allow inbound traffic on port 80 for HTTP and port 443 for HTTPS if needed.
- Review and launch the instance.
Install and Configure a Web Server:
- Connect to your EC2 instance using SSH.
- Update the package index and install a web server like Apache or Nginx.
- Configure the web server to serve your blog content, including setting up virtual hosts and enabling necessary modules.
- Test the web server to ensure it's serving content correctly.
Install and Configure a Blog Platform:
- Choose a blogging platform like WordPress, Drupal, or Ghost.
- Follow the installation instructions provided by the platform's documentation.
- Configure the platform, including database settings, user accounts, and basic site settings.
- Install any necessary plugins or themes to customize your blog's appearance and functionality.
Configure Domains and DNS:
- Register a domain name through a domain registrar.
- Configure DNS records to point your domain to the public IP address of your EC2 instance.
- Consider using AWS Route 53 for managed DNS services, which integrates well with EC2 instances.
Configure Security for Production Environments:
- Obtain an SSL/TLS certificate for your domain to enable HTTPS encryption.
- Configure your web server to use the SSL certificate and redirect HTTP traffic to HTTPS.
- Implement firewall rules and security best practices to protect your EC2 instance from unauthorized access and attacks.
- Regularly update your server's software and monitor for security vulnerabilities.

GCP and Azure Instance Launches

Google Cloud Platform (GCP):
- Sign in to the Google Cloud Console.
- Navigate to Compute Engine and click on "Create Instance".
- Choose an instance type, configure networking options, and add any necessary disks or other resources.
- Follow similar steps as AWS to install and configure a web server, blog platform, and DNS settings.
Microsoft Azure:
- Sign in to the Azure Portal.
- Navigate to Virtual Machines and click on "Add".
- Choose a VM size, configure networking, and add disks as needed.
- Follow similar steps as AWS and GCP for setting up and configuring your blog.

Terraform for Automated Deployments

Set Up Terraform:
- Download and install Terraform from the official website.
- Initialize Terraform in your project directory using terraform init.
Write Terraform Configurations:
- Define your infrastructure resources using Terraform configuration files (.tf).
- Use provider blocks to specify the cloud provider and authentication details.
- Define resources such as instances, networks, security groups, and DNS settings.
- Organize your configurations into modules for reusability and maintainability.
Apply Terraform Configuration:
- Run terraform plan to preview the changes Terraform will make.
- Run terraform apply to apply the configuration and provision resources in the cloud provider.
- Verify that the resources are created as expected and test your deployment.
Launching Multiple Instances:
- Use Terraform's count parameter or for_each loop to create multiple instances with the same configuration.
- Parameterize your configurations to allow for flexibility in instance counts, instance types, and other settings.

Terraform Code for Launching EC2 Instances

terraformCopy code# AWS EC2 Instance
provider "aws" {
  region = "us-east-1" # Change to your desired region
}

resource "aws_instance" "example" {
  ami           = "ami-12345678" # Change to your desired AMI ID
  instance_type = "t2.micro"
  key_name      = "your_key_pair"
  subnet_id     = "subnet-12345678" # Change to your desired subnet ID

  tags = {
    Name = "ExampleInstance"
  }
}

Terraform Code for Launching Instances on GCP and Azure

terraformCopy code# Google Cloud Platform (GCP) Instance
provider "google" {
  project = "your_project_id"
  region  = "us-central1" # Change to your desired region
}

resource "google_compute_instance" "example" {
  name         = "example-instance"
  machine_type = "n1-standard-1"
  zone         = "us-central1-a" # Change to your desired zone

  tags = ["web"]

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-9"
    }
  }

  network_interface {
    network = "default"
    access_config {}
  }
}

# Microsoft Azure Instance
provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "example" {
  name     = "example-resources"
  location = "East US" # Change to your desired region
}

resource "azurerm_linux_virtual_machine" "example" {
  name                = "example-vm"
  resource_group_name = azurerm_resource_group.example.name
  location            = azurerm_resource_group.example.location
  size                = "Standard_B1ls"

  admin_username = "adminuser"
  admin_ssh_key {
    username   = "adminuser"
    public_key = file("~/.ssh/id_rsa.pub")
  }

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  network_interface_ids = [azurerm_network_interface.example.id]
}

resource "azurerm_network_interface" "example" {
  name                = "example-nic"
  location            = azurerm_resource_group.example.location
  resource_group_name = azurerm_resource_group.example.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.example.id
    private_ip_address_allocation = "Dynamic"
  }
}

resource "azurerm_subnet" "example" {
  name                 = "internal"
  resource_group_name  = azurerm_resource_group.example.name
  virtual_network_name = azurerm_virtual_network.example.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_virtual_network" "example" {
  name                = "example-network"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.example.location
  resource_group_name = azurerm_resource_group.example.name
}

These Terraform codes provide a basic setup for launching instances on AWS, GCP, and Azure. You can customize them further based on your specific requirements and configurations. Remember to replace placeholders like AMI IDs, subnet IDs, project IDs, and region names with your actual values.

Remember, the cloud is vast, and Azure is your key to unlocking its full potential. Join us tomorrow as we dive deeper into the azure depths, uncovering more treasures that await on our journey through the cloud. Until then, happy exploring!

Thank you for Reading:)

#Happy Reading!!

Any query and suggestion are always welcome -Nehal IngoleorTwitter