Install Helm

 

What is Helm?

1. Install Helm:

If you haven't already installed Helm on your local machine and your Kubernetes cluster, you can follow the instructions provided in the official Helm documentation: Installing Helm.

2. Add Helm Chart Repositories:

Helm uses repositories to store and retrieve charts. You can add popular Helm chart repositories to your Helm configuration using the helm repo add command. For example:

bash
helm repo add stable https://charts.helm.sh/stable
helm repo add bitnami https://charts.bitnami.com/bitnami

This adds the stable and Bitnami repositories to your Helm configuration, allowing you to search for and install charts from these repositories.

3. Search for Helm Charts:

You can use the helm search repo command to search for Helm charts available in the configured repositories. For example:

bash
helm search repo wordpress

This command searches for Helm charts related to WordPress in the configured repositories.

4. Customize Helm Values:

Before installing a Helm chart, you may need to customize the values used by the chart. You can create a values.yaml file with your custom configuration values or override specific values using the --set flag when installing the chart.

5. Install Helm Charts:

Once you've found the Helm chart you want to install and have customized the values as needed, you can use the helm install command to install the chart. For example:

bash
helm install my-wordpress stable/wordpress -f values.yaml

This command installs the WordPress Helm chart from the stable repository using the values specified in the values.yaml file.

6. Manage Helm Releases:

You can use various Helm commands to manage your Helm releases, such as helm list to list installed releases, helm upgrade to upgrade releases, and helm delete to delete releases.

7. Helm Charts for Your Applications:

If you have custom applications or services that you want to deploy using Helm, you can create your own Helm charts to package and deploy them. The Helm documentation provides guidance on creating charts: Developing Charts.

Steps to Install ArgoCD on EKS:

1. Install ArgoCD using Helm:

   Run the following commands to add the ArgoCD Helm repository and install ArgoCD:

   bash
   # Add ArgoCD Helm repository
   
   helm repo add argo https://argoproj.github.io/argo-helm
   
   
   # Create namespace
   kubectl create namespace argocd
   # Install ArgoCD
   
   helm install argocd argo/argo-cd --name-space argocd
   

2. Wait for ArgoCD Pods to be Ready:

   After installing ArgoCD, wait for the pods to be in the Running state. You can use the following command to monitor the pods:

   bash
   kubectl get pods -n argocd
   

3. Access ArgoCD UI:

   By default, ArgoCD's UI is not exposed externally. To access the UI, you need to create a port forward:

   bash
   kubectl port-forward svc/argocd-server -n argocd 8080:443
   

   Now, you can access the ArgoCD UI by navigating to http://localhost:8080 in your web browser. The default username is admin and the password is the pod name of the ArgoCD API server.

4. Configure ArgoCD:

   Once you're logged into the ArgoCD UI, you can start deploying applications or configuring Git repositories for continuous delivery.

Terraform

 I share with you some key steps to manage infrastructure as code.

I. Non-Variable

1. Install Terraform:

You can install Terraform by downloading the binary distribution for your operating system from the Terraform website. After downloading, extract the binary and add it to your system's PATH.

2. Define Infrastructure as Code (IaC):

Create a directory for your Terraform configuration files. Within this directory, define .tf files that describe the infrastructure resources you want to provision. These files typically include:

• Provider Configuration: Declare the cloud provider you're using (e.g., AWS, Azure, Google Cloud) and any required authentication details.
• Resource Configuration: Define the infrastructure resources you want to create, such as virtual machines, networks, databases, and storage buckets.

3. Initialize Terraform:

Navigate to your Terraform configuration directory in the terminal and run terraform init. This command initializes the directory and downloads any necessary plugins and modules.

4. Write Terraform Configuration:

Write your Terraform configuration files (.tf) using the HashiCorp Configuration Language (HCL). Define providers, resources, variables, outputs, and any other necessary configurations.

5. Plan Infrastructure Changes:

Run terraform plan to create an execution plan. Terraform examines your configuration and determines what actions are necessary to achieve the desired state. It does not execute the plan but shows you what will happen when you apply the configuration.

6. Apply Infrastructure Changes:

Once you review the plan and are satisfied with the proposed changes, you can apply the changes by running terraform apply. Terraform will execute the plan and create, update, or delete resources as needed.

7. Maintain Infrastructure:

As your infrastructure evolves, continue to manage it using Terraform. Make changes to your Terraform configuration files as necessary and apply those changes using terraform apply.

Additional Tips:

• Version Control: Store your Terraform configuration files in version control (e.g., Git) to track changes and collaborate with team members.
• Modules: Use Terraform modules to encapsulate reusable components of your infrastructure configuration.
• Variables and Outputs: Utilize variables to parameterize your configuration and outputs to extract useful information about your infrastructure.

Example Terraform Configuration:

Here's a simple example of a Terraform configuration file that provisions an AWS EC2 instance:

hcl
provider "aws" { 
 region = "ap-southeast-1" 
}


resource "aws_instance" "example" { 
 ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro" 
}

This configuration declares an AWS provider in the us-west-2 region and creates an EC2 instance using the specified AMI and instance type.

II. Variable

1. Create Terraform Variable Files:

Create separate Terraform variable files for each environment (e.g., dev.tfvars, prod.tfvars in envs folder). These files will contain environment-specific variable values.

Example dev.tfvars:

hcl
region = "us-west-2"
instance_type = "t2.micro"

Example prod.tfvars:

hcl
region = "us-east-1"
instance_type = "t2.large"

2. Reference Variables in Terraform Configuration:

Reference the variables defined in your variable files in your Terraform configuration files using interpolation syntax.

Example main.tf:

hcl
provider "aws" { 
 region = var.region 
}
resource "aws_instance" "example" { 
 ami           = "ami-12345678" 
 # AMI ID specific to your environment 
 instance_type = var.instance_type 
}

3. Run Terraform Commands with Variable Files:

When running Terraform commands, specify the variable files for the appropriate environment using the -var-file option.

For example, to apply changes to the development environment:

bash
terraform apply -var-file=../envs/dev.tfvars 

For the production environment:

bash
terraform apply -var-file=../envsprod.tfvars

3. Run Terraform Destroy

Once you're in the directory, execute the following command:

bash
terraform destroy

Additional Tips:

• Use .gitignore to exclude sensitive variable files (e.g., *.tfvars) from version control.
• Define default variable values in your Terraform configuration files or in a variables.tf file to provide fallback values if variables are not defined in the variable files.

• 
  

•  

After I run terraform apply successfully:

• 

•