DEV Community: pankaj892

Devops pipeline on a Golang Web App with Gitops and Kubernetes

pankaj892 — Wed, 23 Oct 2024 08:00:37 +0000

In this blog post I'll walk you through the journey of automating the deployment of a web app in golang with CI/CD pipelines and using Gitops approach.

We'll go through containerizing our app to deploying it on kubernetes to using ArgoCD for deployment.

Requirements

A kubernetes cluster You can use any of the managed services from cloud providers for kubernetes or if your system has enough resources to provision a kubernetes cluster you can setup a local kubernetes cluster using Minikube/kind
A github account A free account is sufficient enough as we will be using Github Actions for Continuous Integration (CI)
A dockerhub account We'll be using dockerhub to pull container images
Eagerness to learn
Not giving up This is the important one you'll face problems and you should be able to troubleshoot them and resolve them. I had to troubleshoot a lot of times before I can complete this project.

Lets start

Containerizing the app with Multi-stage docker builds

For the web app to be available on all machines we have to containerize it and when containerization is the word what's best than docker.
I created a Dockerfile to run the app but I have used multi-stage format

Why multi-stage builds ?

The reason is simple if I create an image in a single stage it would consume more space on the machine whereas by using multi-stage builds we optimize the final size of the image by seperating build and runtime environments and also reduce the attack surface of our image for better security

Here's how you can do it

Create a dockerfile
Compile the application in the build stage
Copy the compiled binary to a minimal base image
Build the image and push it to dockerhub so the image can be used by Github Actions in CI

# Start with a base image
FROM golang:1.22 as base
WORKDIR /app
COPY go.mod ./
RUN go mod download
COPY . .
RUN go build -o main .

#######################################################
# Reduce the image size using multi-stage builds
# We will use a distroless image to run the application
FROM gcr.io/distroless/base

# Copy the binary from the previous stage
COPY --from=base /app/main .

# Copy the static files from the previous stage
COPY --from=base /app/static ./static

# Expose the port on which the application will run
EXPOSE 8080

# Command to run the application
CMD ["./main"]

Now that we have the dockerfile let's build it and deploy it to dockerhub

docker build -t pankaj892/webapp:v1 .

We try to check whether app works as expected on local machine
docker run -p 8080:8080 pankaj892-webapp:v1

Lets push it to dockerhub
docker push pankaj892/webapp:v1 .

Kubernetes cluster creation

You can create a cluster locally using mininkube/kind or use any one of the managed solutions on cloud. I'll be using Elastic Kubernetes Service(EKS) from AWS.

You can launch a cluster in EKS using console or from commandline. I'll be using the commandline

eksctl create cluster--instance-selector-vcpus=2 --instance-selector-memory=4 --name <name-of-cluster> --region <region-code>

This will choose only those machine types for node groups which have 2 vCPUs and memory of 4gb

Helm chart creation and configuration

We can deploy all the resources one by one but it would be difficult to manage them as they scale this is where Helm comes in it acts as a package manager to manage all of our resources with the use of charts

Create a helm chart

helm create web-app

Helm will create files for our use but we don't need most of them for our project.

Create the following files and add them in the helm directory

Deployment

# This is a sample deployment manifest file for a simple web application.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: {{ .Values.image.repository }}:{{ .Values.image.tag }}
        ports:
        - containerPort: 8080

Service

# Service for the application
apiVersion: v1
kind: Service
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
  selector:
    app: web-app
  type: ClusterIP

Ingress

# Ingress resource for the application
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-app
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: web-app.local
    http:
      paths: 
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-app
            port:
              number: 80

Update the values file to this

# Default values for web-app.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: pankaj892/webapp
  pullPolicy: IfNotPresent
  # Overrides the image tag whose default is the chart appVersion.
  tag: "11440208844"

imagePullSecrets: []
nameOverride: ""
fullnameOverride: ""

service:
  type: ClusterIP
  port: 80

ingress:
  enabled: false
  className: ""
  annotations: {}
    # kubernetes.io/ingress.class: nginx
    # kubernetes.io/tls-acme: "true"
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: ImplementationSpecific
  tls: []
  #  - secretName: chart-example-tls
  #    hosts:
  #      - chart-example.local

Helm part is done now let's move on to deploying our CI

Continuous Integration (CI) with Github Actions

Github Actions allow us to automate the build process of our app based on some events in our repo like push,pull.

Let's create our pipeline file
Workflow file is stored in (.github/workflows/cicd.yml)

# CICD using GitHub actions

name: CI and Deploy to ArgoCD

# Exclude the workflow to run on changes to the following files
on:
  push:
    branches:
      - main
    paths-ignore:
      - 'helm/**'
      - 'README.md'

jobs:

  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v4

    - name: Set up Go 1.22
      uses: actions/setup-go@v2
      with:
        go-version: 1.22

    - name: Build binary
      run: go build -o web-app

    - name: Test code
      run: go test ./...

  push:
    runs-on: ubuntu-latest

    needs: build

    steps:
    - name: Checkout repository
      uses: actions/checkout@v4

    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v1

    - name: Login to DockerHub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}

    - name: Build and Push action
      uses: docker/build-push-action@v6
      with:
        context: .
        file: ./Dockerfile
        push: true
        tags: ${{ secrets.DOCKERHUB_USERNAME }}/webapp:${{github.run_id}}

  update-newtag-in-helm-chart:
    runs-on: ubuntu-latest

    needs: push

    steps:
    - name: Checkout repository
      uses: actions/checkout@v4
      with:
        token: ${{ secrets.TOKEN }}

    - name: Update tag in Helm chart
      run: |
        sed -i 's/tag: .*/tag: "${{github.run_id}}"/' helm/web-app/values.yaml

    - name: Commit and push changes
      run: |
        git config --global user.email "pankaj28988@gmail.com"
        git config --global user.name "pankaj892"
        git add helm/web-app/values.yaml
        git commit -m "fix: Update tag in Helm chart"
        git push

This workflow file first builds our image from dockerfile then pushes it to dockerhub and then updates the tag of the image in our charts.yaml file in helm.

Setting up ArgoCD for Continuous Delivery

We will use argocd for our Cd pipeline since argocd will be able to pick up changes from our git repo and update them in the app.

Lets install argocd on our cluster

kubectl create namespace argocd kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

To access the argocd server we need to change the service to loadbalancer type

kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

For windows this would be
kubectl patch svc argocd-server -n argocd -p '{\"spec\": {\"type\": \"LoadBalancer\"}}'

If it doesn't work just edit service through kubectl and change the type to LoadBalancer it should work

Now get the ip of the service

kubectl get svc argocd-server -n argocd

We got the ip but we need the password to login to argocd

kubectl get secret argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 --decode

This command would get the password and decode the password since the password is encoded in base64 format

After logging in click on New Project > Add the name for your project > Add the repo so that argocd can sync the repo argocd will automatically look for values file and pick that up after that click on submit

Ingress and DNS Mapping

We built our pipeline but how do we access our app you can't put in the cluster url from EKS everytime to access it we need to use an ingress for this

I am using Nginx Ingress from AWS so that I can access the app

Deploy the ingress on our cluster

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.11.1/deploy/static/provider/aws/deploy.yaml

Now ingress is deployed and we need to add the ip of our cluster from EKS in our local hosts file for linux its /etc/hosts for windows it is in C:\Windows\System32\etc\hosts

<ip-of-cluster> web-app.local

Now we can access our app on web-app.local

We have done all the steps lets test our app

As you can see the url at the top is what we defined in our hosts file

We have the app running lets add something and commit to our repo so argocd can pick up that change and deploy to app

I made a change to me repo and this should trigger the pipeline

Pipeline has started and after its completion lets see whether argocd picks up that change

Yes we see changes in our app argocd did pick up changes and synced our app with the latest changes

If you made it this far then congrats!!!

This project has been a great learning experience for me right from deploying kubernetes on AWS to creating my pipelines and deployments and troubleshooting them. This project helped me create an end-to-end devops pipeline for a go app and it can be scalable based on needs. I plan to explore more like maybe deploying the eks clutser using terraform or cloudformation stacks and refine more.

If you get stuck somewhere you can reference this repo

Let me know in the comments how was your experience building this pipeline.

Monitoring a Kubernetes Cluster using Prometheus and Grafana with Helm

pankaj892 — Tue, 23 Jul 2024 11:52:08 +0000

Monitoring a Kubernetes cluster is essential for maintaining its health, optimizing performance, and ensuring reliability. Prometheus and Grafana are industry-standard tools that, when combined, offer robust monitoring, alerting, and visualization capabilities.
In this guide, we'll walk through deploying Prometheus and Grafana on Kubernetes using Helm charts, streamlining the setup process for efficient monitoring.

Why Use Prometheus and Grafana?

Prometheus:
1. Scalability: Easily handles high cardinality metrics and dynamic service discovery within Kubernetes.
2. Flexibility: Supports custom metrics and powerful querying capabilities.
3. Reliability: Time-series database optimized for fast querying of metrics data.
Grafana:
1. Visualization: Provides intuitive, customizable dashboards for visualizing Prometheus metrics.
2. Alerting: Configurable alerts based on metric thresholds or specific conditions.
3. Integration: Easily integrates with various data sources, including Prometheus, to consolidate monitoring data.

Prerequisites

Kubernetes Cluster: Ensure you have access to a Kubernetes cluster where you can deploy applications. You can set it up locally using KinD/Minikube or use one hosted on the cloud.
Helm: Install Helm on your local machine and initialize it to connect to your Kubernetes cluster. If you haven't installed Helm yet, follow the instructions here.

Deploying Prometheus with Helm

Step 1: Add Prometheus Helm Repository

$ helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
$ helm repo update

Step 2: Install Prometheus

$ helm install prometheus prometheus-community/prometheus

This command installs Prometheus with default configurations suitable for monitoring Kubernetes.

Step 3: Access Prometheus UI To access the Prometheus UI, port-forward the Prometheus server pod to your local machine:

$ kubectl port-forward service/prometheus-server 9090:80

Open http://localhost:9090 in your web browser to access the Prometheus expression browser and other features.

Deploying Grafana with Helm

Grafana can also be easily deployed using the official Helm chart from the Grafana community repository.

Step 1: Add Grafana Helm Repository

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update

Step 2: Install Grafana

helm install grafana grafana/grafana

This installs Grafana with a default admin password. Retrieve the password using:

kubectl get secret --namespace default grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

Step 3: Access Grafana UI To access the Grafana UI, port-forward the Grafana pod to your local machine:

kubectl port-forward service/grafana 3000:3000

Open http://localhost:3000 in your web browser. Log in with username admin and the password retrieved earlier.

After logging in you are greeted with the following UI

Configuring Prometheus Data Source in Grafana

Once both Prometheus and Grafana are running, we need to configure Grafana to use Prometheus as a data source.

Navigate to Configuration > Data Sources > Add data source.
Choose Prometheus as the type.

Configure the URL to http://url_of_prometheus_server
Save and test the data source at bottom to ensure it connects successfully.

Importing Grafana Dashboards

Grafana provides pre-built dashboards for monitoring Kubernetes clusters. You can import these dashboards to visualize metrics collected by Prometheus.

Go to Create > Import in Grafana.
Use the dashboard IDs from Grafana's official repository or community dashboards.
I am using the official one from Grafana you can find it here

Select the Prometheus data source you configured earlier.
And now we can see our dashboard which is collecting metrics from Prometheus and displaying it on dashboard in realtime

You can customize the imported dashboard as needed to monitor your Kubernetes cluster effectively.

Conclusion

Deploying Prometheus and Grafana using Helm charts simplifies the setup and configuration of monitoring for your Kubernetes cluster. This setup provides scalable metric collection, robust visualization capabilities, and flexible alerting mechanisms. By leveraging these tools, you can gain deep insights into your Kubernetes infrastructure's performance and ensure proactive management of your applications.

If you have any questions comment it down I'll try to help

CI/CD pipeline using Jenkins and Docker

pankaj892 — Tue, 02 Jul 2024 11:11:53 +0000

Today we will be creating a CI/CD pipeline in Jenkins which fetches code from github and creates an image from Dockerfile and runs our app in a docker container and terminates automatically after scheduled time

1. Creating EC2 instances

I have used AWS EC2 to launch an ubuntu instance which comes under free tier you can try it on your local machine or use a VM from any public cloud provider

Now connect to the instance

2. Setting up Jenkins & Docker

We need to update our installation package manager

$ sudo apt update

Jenkins needs java to run so we'll proceed with installing Java first

$ sudo apt install openjdk-11-jre

Check if java is installed correctly

Now we download Jenkins using curl command

$ curl -fsSL https://pkg.jenkins.io/debian/jenkins.io.key | sudo tee \   /usr/share/keyrings/jenkins-keyring.asc > /dev/null

We add it to our package manager

$ echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \   https://pkg.jenkins.io/debian binary/ | sudo tee \   /etc/apt/sources.list.d/jenkins.list > /dev/null

Lets update our package manager once

$ sudo apt-get update

Now install jenkins

$ sudo apt-get install jenkins

Before we can use jenkins we need to enable it first

$ sudo systemctl enable jenkins

Start jenkins server

$ sudo systemctl start jenkins

Check status of jenkins

$ sudo systemctl status jenkins

You would get a response like this

Jenkins runs on port 8080 by default go to localhost:8080 to access it.
Since I have a VM provisioned in the cloud I need to open port 8080 to allow connections
I went to Network security groups and added the port number I want to access.

Since I don't want everyone to able to access jenkins I have limited the port to only a single host

Now when I login to port 8080 I am greeted with a login screen of jenkins

Now to login we need credentials
Username is admin
password can be found through the following command

$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword

After logging into jenkins change your password and jenkins would ask to install plugins let it install them

Now we are greeted with a screen like this click on new item

Since I plan to keep it simple click on freestyle project

After adding the name for you app add your github repo you want to connect

After adding a repo we need to tell jenkins how to access the repo and give it required permission so it can fetch the code from repo
To achieve this I have used SSH keys simple generate a ssh key and add the public key in github

Now we need to add private key in jenkins so that it can authenticate with github and pull code from our repo.
Click on add below credentials and choose Jenkins

Give a name to you credential and add the private key

Before we move to next step install a plugin called Github Integration available in Jenkins you can do this by going to manage jenkins and selecting plugins and search for the extension

Now add the steps to build the app and run it. Since our app runs on node.js I will be using a docker container. I have created a Dockerfile
to do this.
I am using shell scripting to run the container in a shell and exit it

The commands in above image do the following things:

Build the docker image
Run the app in a container on port 8000
The app will be live for 5 minutes
After that the container is stopped and removed from the machine

The Build ID with a $ is an environment variable which changes according to build of jenkins so we get a new container on every run and there won't be any problems as we won't be running same container everytime

Click Save when done

We need docker to run the app if you don't have install it on your machine

$ sudo apt install docker.io

We also need a Dockerfile
You can find it on my repository here

Dockerfile does the following:

It pulls the latest node image from DockerHub
The work directory is set as app
It runs npm install and all libraries and packages are downloaded
It exposes port 8000 for our app
It runs the command node app.js in a shell

Lets move on to next stage

3. Configuring Github

We need to make sure that when a change is detected in our repo jenkins runs the pipeline automatically we use webhooks to achieve this

Go to Settings > Webhooks for your repo not your account

Now add url of your jenkins where it is hosted followed by /github-webhook/ and click on save

4. Testing our app

Now lets do a dry run and see if our pipeline works as expected

Click on build now to run the pipeline

Build has started

I expect the container name to end with build number let's check

It is working as expected

And pipeline is successful since we can see our app

Now lets change something in repo and see if jenkins picks it up and runs the pipeline
I changed the background and some text

It is working as expected

We have completed this project successfully

If you have any questions comment down below I'll be happy to help

Deploying applications to Kubernetes with Gitlab CI/CD,Helm Charts and ArgoCD

pankaj892 — Mon, 01 Jul 2024 10:59:26 +0000

In my last post I talked about Gitops and how it helps in automation you can read about it 👉here

In this post we'll be doing a project using GitOps methodology and tools like ArgoCD

Workflow

Let me take you through the project flow-

Developers commit code to git repository
After code is commited a CI pipeline is triggered in gitlab which has the job of building an image and tagging it and updating the image in the repository which hosts the manifest files.
After the job is completed the pipeline pushes the images to a container registry like dockerhub,gitlab etc.
ArgoCD syncs the manifest repo which contains helm charts and values
ArgoCD deploys the changes to Kubernetes cluster and changes reflect in the application

Before we begin we need a kubernetes cluster up and running you can deploy a cluster in one of the many cloud environments or you can run it locally using tools like Minikube,Rancher Desktop to name a few

I prefer running my cluster on cloud since it takes away a lot of stress for setting it up locally.

1.Setting up the cluster

I have used Azure Kubernetes Service (AKS) for deploying kubernetes in Azure. It is a managed Kubernetes solution provided by Azure where we have access to nodes and Azure takes care of control plane.

As you can see in above images we have our cluster set up and ready we can we now move to our next step which is setting up the gitlab pipeline

2. Setting up CI pipeline in Gitlab

I have used gitlab for CI/CD since I believe it has a lot of options and support for CI/CD. You can choose any other CI tool like CircleCI, Jenkins to name a few
I have created 2 repos-

code-repo
This repo hosts the Dockerfile and the source code of our app
Manifest repo
This repo hosts helm charts and yaml files for deployment of our app to kubernetes

In gitlab to setup a pipeline we need to define it in a yaml file called .gitlab-ci.yml

Make sure your pipeline looks like below

The pipeline consisits of 2 stages - build and helm-chart-updation

Build Stage

In this stage the pipeline logs into the container registry based on the credentials defined in the environment variables and builds the docker image and pushes it to container registry which in our project is the gitlab container registry. Also we login to the repo through SSH Keys which I have provided as an variable for CI/CD

Helm chart updation

In this stage the pipeline after logging in by the SSH Key updates the values.yaml file in manifest repo to the current image from container registry with the latest tag so I don't have to manually change the tag after every run.

Now let's run the pipeline

My pipeline ran successfully. Now lets move on to setting up argoCD

3. ArgoCD

ArgoCD automates the deployment of applications to multiple Kubernetes clusters while maintaining desired state configuration stored in Git repositories. ArgoCD continuously monitors these repositories for changes, ensuring applications are always synchronized with the declared configuration. Its robust capabilities include automated rollbacks, extensive deployment auditing, and a user-friendly UI for visualizing and managing application deployments across environments. It is a core component in GitOps practices.

Enough said lets start

ArgoCD can be installed on your cluster by



$ kubectl create namespace argocd
$ kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Access the argoCD server



$ kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

ArgoCD provides documentation which seems easy to follow you can access it here

Now lets log in to argoCD server
Before we can add our app we need to connect our repo.
Go to settings and go to repositories

Now add our repo details and connect

If connection is successful it will show a successful status

Now click on add app to connect our app

Add the name of your app you can give any name but it should be lowercase

Add source and destination for your app

Since my repo has a values.yaml file and it is a helm chart so details are automatically picked up by argoCD

After adding details and creating your app you will see a screen like this which shows the appname and if you click on it you will get more details

4. Testing the app

We have completed our app setup and it is synchronizing with our repo but how do we find the address where it will be hosted

After going to the link we have our app now ready

Now lets test it I will try to change the backgroud image of our app

After committing my change the pipeline starts

And background image of our app has been changed successfully

Congratulations on completing this project and making it till here.

If you have any questions comment them down I would be happy to help you

GitOps: Streamlining Kubernetes Application Deployment with GitLab CI/CD, Helm Charts, and ArgoCD

pankaj892 — Mon, 01 Jul 2024 06:38:29 +0000

In the realm of modern software development and deployment practices, GitOps has emerged as a robust methodology for managing Kubernetes applications efficiently. This approach leverages Git as the single source of truth for declarative infrastructure and application code, ensuring consistency, traceability, and collaboration across development teams. In this blog post, we'll delve into the core concepts of GitOps and explore how GitLab CI/CD, Helm Charts, and ArgoCD synergistically enable streamlined application deployment on Kubernetes.

Understanding GitOps

GitOps represents a paradigm shift towards managing infrastructure and applications through version-controlled repositories, typically using Git. The key principles of GitOps include:

Declarative Configuration: Infrastructure and application state are described declaratively and stored as code in Git repositories.
Version Control: Git provides a versioned history of changes, enabling rollbacks, audits, and collaboration among team members.
Automation: Continuous Integration/Continuous Deployment (CI/CD) pipelines automate the deployment process, triggered by Git repository events.
Observability and Monitoring: GitOps encourages observability by integrating monitoring and alerting tools with CI/CD pipelines to ensure reliability and performance.

GitLab CI/CD: Automating Builds and Deployments

GitLab CI/CD plays a pivotal role in the GitOps workflow by automating build, test, and deployment processes directly from GitLab repositories. Here's how it works:

Pipeline Configuration: Developers define CI/CD pipelines using .gitlab-ci.yml files, specifying stages such as build, test, and deploy.
Triggering Deployments: Changes pushed to specific branches or tags trigger pipeline executions, ensuring that deployments are automatically synchronized with code changes.
Integration with Kubernetes: GitLab integrates seamlessly with Kubernetes clusters, enabling deployment of Helm Charts and other Kubernetes resources directly from CI/CD pipelines.

Helm Charts: Packaging Kubernetes Applications

Helm is a package manager for Kubernetes that simplifies the deployment and management of applications. Helm Charts encapsulate Kubernetes manifests, making it easier to define, version, and share complex application configurations.

Chart Repositories: Helm Charts are stored in repositories and referenced in CI/CD pipelines for consistent deployment across environments.
Parameterization: Helm Charts support templating and parameterization, allowing customization of configurations for different environments or deployment scenarios.

ArgoCD: Continuous Deployment and GitOps

ArgoCD is a GitOps continuous delivery tool for Kubernetes that ensures applications are deployed and maintained consistently across clusters.

Declarative GitOps Workflows: ArgoCD continuously monitors Git repositories for changes and reconciles them with the desired state defined in Helm Charts or Kubernetes manifests.
Automatic Synchronization: Any changes to the Git repository trigger automatic synchronization and deployment updates to Kubernetes clusters, ensuring consistency and reliability.
Rollback and Versioning: ArgoCD provides rollbacks to previous versions and maintains an audit trail of deployments, enhancing traceability and resilience.

Conclusion

GitOps, powered by GitLab CI/CD, Helm Charts, and ArgoCD, represents a transformative approach to Kubernetes application deployment. By centralizing configuration management, automating deployment workflows, and enhancing observability, organizations can achieve greater efficiency, reliability, and collaboration in their DevOps practices. Embracing GitOps not only streamlines deployment processes but also fosters a culture of continuous improvement and innovation in modern software development teams.

In summary, GitOps isn't just a methodology but a fundamental shift towards more efficient and reliable Kubernetes operations, leveraging the power of Git and modern CI/CD tools to drive application deployment and management forward.

LAMP Stack in Microsoft Azure

pankaj892 — Fri, 13 Jan 2023 16:28:53 +0000

Hello 👋
I am Pankaj a beginner at cloud computing ☁️ I started my journey with Linux 🐧. I learnt shell scripting and even made a few of them but I didn't know how to enforce my learnings.

So i searched for some projects to get acquainted with cloud and I came up on LAMP stack.LAMP is an acronym for Linux,Apache Server,MySql,PHP all of these make as a base for an application it is used widely to develop applications in the cloud.

So let's start

For this tutorial I assume you know how to create a VM in Azure if not check this from Microsoft Learn

1.Connecting to VM

Use ssh to connect to the VM(Virtual Machine) hosted in Azure

After connecting you might get a below screen based on the Linux VM you created I went with Ubuntu but you can use any Linux based VM

2.Installing Apache server

Run the above command to update the apt repository

Now we install apache server with the above command press Y if asked

You can check if server is installed correctly by going to the ip address of the VM. If you get the above image be proud that you have completed an important task in LAMP stack.

3.Installing MySQL database

Now lets move onto installing MySql database

We will install mysql server using the above command and enter Y when asked during installation.

Now comes the part to harden the sql installation so it can be saved from attacks

After executing this command you need to set a password it should be different from the one you used for your VM (in case you used a password for connecting VM in Azure)

Connect to sql database using the password you set earlier in the previous command.
You can see you get a sql prompt if password is correct
Type exit to come out of sql

Finally you are done with SQL installation now lets move on to php installation

4.Installing PHP

Install php using the command above and press Y i asked during installation.

Now we will install phpmyadmin to access the php dashboard and also for accessing the database.

5.Next steps

We need to restart apache server in order to take efect the changes we made to system

Select the apache server using spacebar and navigate to the OK button using TAB

You can set the password or let phpmyadmin automatically generate one for you.

And you are done with the LAMP stack installation.
Be proud of yourself that you completed the most used task in cloud computing and Welcome to the Cloud ☁️