DevOpsifying einer Go-Webanwendung: Ein End-to-End-Leitfaden

Einführung

In diesem Beitrag werde ich Sie durch den Prozess der DevOpsifizierung einer Go-basierten Webanwendung führen. Wir werden alles abdecken, von der Containerisierung der Anwendung mit Docker bis zur Bereitstellung auf einem Kubernetes-Cluster (AWS EKS) mit Helm, der Einrichtung einer kontinuierlichen Integration mit GitHub Actions und der Automatisierung von Bereitstellungen mit ArgoCD. Am Ende dieses Tutorials verfügen Sie über eine voll funktionsfähige, CI/CD-fähige Go-Webanwendung.

Voraussetzungen

Bevor Sie mit diesem Projekt beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

AWS-Konto: Sie benötigen ein aktives AWS-Konto, um Ihren EKS-Cluster für die Bereitstellung der Go-basierten Anwendung zu erstellen und zu verwalten.

DockerHub-Konto: Sie sollten über ein DockerHub-Konto verfügen, um Ihre Docker-Images zu übertragen.

Grundlegende DevOps-Kenntnisse: Vertrautheit mit DevOps-Konzepten und -Praktiken ist unerlässlich, einschließlich des Verständnisses von CI/CD-Pipelines, Containerisierung, Orchestrierung und Cloud-Bereitstellung.

Helm: Zum Verpacken und Bereitstellen Ihrer Anwendung sind Grundkenntnisse von Helm, dem Kubernetes-Paketmanager, erforderlich.

Wenn Sie diese Voraussetzungen erfüllen, sind Sie gut darauf vorbereitet, die Schritte in diesem Leitfaden zu befolgen und Ihre Go-basierte Anwendung erfolgreich als DevOpsify zu entwickeln!

Schritt 1: Holen Sie sich den Quellcode

Um mit dem Projekt zu beginnen, müssen Sie den Quellcode aus dem GitHub-Repository klonen. Verwenden Sie den folgenden Befehl, um das Projekt zu klonen:

git clone https://github.com/iam-veeramalla/go-web-app-devops.git

Dieses Repository enthält alle notwendigen Dateien und Konfigurationen zum Einrichten und Bereitstellen der Go-basierten Anwendung mithilfe der in diesem Handbuch beschriebenen DevOps-Praktiken. Nach dem Klonen können Sie durch die folgenden Schritte navigieren und diese befolgen, um die Anwendung zu containerisieren, bereitzustellen und zu verwalten.

Schritt 2: Containerisierung der Go-Webanwendung

Der erste Schritt besteht darin, unsere Go-Anwendung zu containerisieren. Wir werden eine mehrstufige Docker-Datei verwenden, um die Go-Anwendung zu erstellen und ein leichtes, produktionsbereites Image zu erstellen.

FROM golang:1.22.5 as build

WORKDIR /app

COPY go.mod .

RUN go mod download

COPY . .

RUN go build -o main .

FROM gcr.io/distroless/base

WORKDIR /app

COPY --from=build /app/main .

COPY --from=build /app/static ./static

EXPOSE 8080

CMD ["./main"]

Befehle zum Erstellen und Pushen eines Docker-Images:

docker login
docker build . -t go-web-app
docker push go-web-app:latest

In dieser Docker-Datei verwendet die erste Stufe das Golang-Image, um die Anwendung zu erstellen. Die zweite Stufe verwendet ein verteilungsloses Basis-Image, das viel kleiner und sicherer ist und nur die notwendigen Dateien zum Ausführen unserer Go-Anwendung enthält.

Schritt 3: Bereitstellung auf Kubernetes mit AWS EKS

Als nächstes stellen wir unsere Containeranwendung in einem Kubernetes-Cluster bereit. So können Sie Ihren Cluster einrichten und Ihre App bereitstellen.

Erstellen Sie einen EKS-Cluster:

eksctl create cluster --name demo-cluster --region us-east-1

Bereitstellungskonfiguration (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-web-app
  labels:
    app: go-web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: go-web-app
  template:
    metadata:
      labels:
        app: go-web-app
    spec:
      containers:
      - name: go-web-app
        image: iamamash/go-web-app:latest
        ports:
        - containerPort: 8080

Dienstkonfiguration (service.yaml):

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

Ingress-Konfiguration (ingress.yaml):

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

Wenden Sie die Konfigurationen mit kubectl an:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

Einrichten des Nginx-Ingress-Controllers:

Ein Ingress-Controller in Kubernetes verwaltet den externen Zugriff auf Dienste innerhalb des Clusters und verarbeitet normalerweise HTTP- und HTTPS-Verkehr. Es bietet zentralisiertes Routing, sodass Sie Regeln definieren können, wie der Datenverkehr Ihre Dienste erreichen soll. In diesem Projekt verwenden wir den Nginx-Ingress-Controller, um den Datenverkehr effizient zu verwalten und an unsere Go-basierte Anwendung weiterzuleiten, die im Kubernetes-Cluster bereitgestellt wird.

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

Schritt 4: Verpacken mit Helm

Um unsere Kubernetes-Ressourcen effektiver zu verwalten, verpacken wir unsere Anwendung mit Helm, einem Paketmanager für Kubernetes.

Erstellen Sie ein Helmdiagramm:

helm create go-web-app-chart

Ersetzen Sie nach dem Erstellen des Diagramms alles im Vorlagenverzeichnis durch Ihre Dateien „deployment.yaml“, „service.yaml“ und „ingress.yaml“.

Werte.yaml aktualisieren: Die Datei „values.yaml“ enthält dynamische Werte, wie das Docker-Image-Tag. Dieses Tag wird automatisch basierend auf der GitHub Actions-Ausführungs-ID aktualisiert, um sicherzustellen, dass jede Bereitstellung eindeutig ist.

# Default values for go-web-app-chart.
replicaCount: 1

image:
  repository: iamamash/Go-Web-App
  pullPolicy: IfNotPresent
  tag: "10620920515" # Will be updated by CI/CD pipeline

ingress:
  enabled: false
  className: ""
  annotations: {}
  hosts:
    - host: chart-example.local
      paths:
        - path: /
          pathType: ImplementationSpecific

Helm-Bereitstellung:

kubectl delete -f k8s/.
helm install go-web-app helm/go-web-app-chart
kubectl get all

Schritt 5: Kontinuierliche Integration mit GitHub-Aktionen

Um die Erstellung und Bereitstellung unserer Anwendung zu automatisieren, richten wir mithilfe von GitHub Actions eine CI/CD-Pipeline ein.

GitHub Actions Workflow (.github/workflows/cicd.yaml):

name: CI/CD

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
      run: go build -o go-web-app

    - name: Test
      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 }}/go-web-app:${{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/go-web-app-chart/values.yaml

    - name: Commit and push changes
      run: |
        git config --global user.email "ansari2002ksp@gmail.com"
        git config --global user.name "Amash Ansari"
        git add helm/go-web-app-chart/values.yaml
        git commit -m "Updated tag in Helm chart"
        git push

To securely store sensitive information like DockerHub credentials and Personal Access Tokens (PAT) in GitHub, you can use GitHub Secrets. To create a secret, navigate to your repository on GitHub, go to Settings > Secrets and variables > Actions > New repository secret. Here, you can add secrets like DOCKERHUB_USERNAME, DOCKERHUB_TOKEN, and TOKEN. Once added, these secrets can be accessed in your GitHub Actions workflows using ${{ secrets.SECRET_NAME }} syntax, ensuring that your sensitive data is securely managed during the CI/CD process.

Step 6: Continuous Deployment with ArgoCD

Finally, we implement continuous deployment using ArgoCD to automatically deploy the application whenever changes are pushed.

Install ArgoCD:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'
kubectl get svc argocd-server -n argocd

Setup ArgoCD Project: To access the ArgoCD UI after setting it up, you first need to determine the external IP of the node where ArgoCD is running. You can obtain this by running the command:

kubectl get nodes -o wide

Next, get the port number at which the ArgoCD server is running using:

kubectl get svc argocd-server -n argocd

Once you have the external IP and port number, you can access the ArgoCD UI by navigating to http://:. For example, if the external IP is 54.161.25.151 and the port number is 30498, the URL to access ArgoCD UI would be http://54.161.25.151:30498.

To log in to the ArgoCD UI for the first time, use the default username admin. The password can be retrieved from the ArgoCD secrets using:

kubectl edit secret argocd-initial-admin-secret -n argocd

Copy the encoded password from the data.password field and decode it using base64:

echo <encoded-password> | base64 --decode

For example, if the encoded password is kjasdfbSNLnlkaW==, decoding it with:

echo kjasdfbSNLnlkaW== | base64 --decode

will provide the actual password. Be sure to exclude any trailing % symbol from the decoded output when using the password to log in.

Now, after accessing the ArgoCD UI, since both ArgoCD and the application are in the same cluster, you can create a project. To do this, click on the "New App" button and fill in the required fields, such as:

• App Name: Provide a name for your application.
• Sync Policy: Choose between manual or automatic synchronization.
• Self-Heal: Enable this option if you want ArgoCD to automatically fix any drift.
• Source Path: Enter the GitHub repository URL where your application code resides.
• Helm Chart Path: Specify the path to the Helm chart within your repository.
• Destination: Set the Cluster URL and namespace where you want the application deployed.
• Helm Values: Select the appropriate values.yaml file for your Helm chart.

After filling in these details, click on "Create" and wait for ArgoCD to create the project. ArgoCD will pick up the Helm chart and deploy the application to the Kubernetes cluster for you. You can verify the deployment using:

kubectl get all

That's all you need to do!

Conclusion

Congratulations! You have successfully DevOpsified your Go web application. This end-to-end guide covered containerizing your application with Docker, deploying it with Kubernetes and Helm, automating builds with GitHub Actions, and setting up continuous deployments with ArgoCD. You are now ready to manage your Go application with full CI/CD capabilities.

Feel free to leave your comments and feedback below! Happy DevOpsifying!

Reference

For a detailed video guide on deploying Go applications on AWS EKS, check out this video.

Das obige ist der detaillierte Inhalt vonDevOpsifying einer Go-Webanwendung: Ein End-to-End-Leitfaden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!