Cloud and DevOps

Deploying Go Applications on AWS, GCP, and Azure

Deploying Go applications on cloud platforms such as AWS, GCP, and Azure involves understanding the specific services and deployment strategies each platform offers. This section provides a detailed guide on how to deploy Go applications using the most commonly used services from each cloud provider.

1. Deploying on AWS

Using AWS Elastic Beanstalk
- Overview: Elastic Beanstalk is a Platform as a Service (PaaS) that simplifies the process of deploying, managing, and scaling web applications and services.
- Steps to Deploy:
  1. Create a New Elastic Beanstalk Application:
```
sh
eb init -p go go-app --region us-west-2
```
  2. Create and Configure Environment:
```
sh
eb create go-app-env
```
  3. Deploy Your Application:
```
sh
eb deploy
```
  4. Open Application in Browser:
```
sh
eb open
```

Using AWS Lambda with API Gateway

Overview: AWS Lambda allows you to run code without provisioning or managing servers. API Gateway provides a way to create and manage APIs.

Steps to Deploy:

Write a Lambda Function:

go
package main

import (
    "context"
    "fmt"
    "github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, name string) (string, error) {
    return fmt.Sprintf("Hello, %s!", name), nil
}

func main() {
    lambda.Start(handler)
}

Create a Deployment Package:

sh
GOOS=linux GOARCH=amd64 go build -o main main.go
zip deployment.zip main

Deploy to Lambda:

sh
aws lambda create-function --function-name go-lambda --zip-file fileb://deployment.zip --handler main --runtime go1.x --role arn:aws:iam::account-id:role/execution_role

Create API Gateway:
- Set up an API Gateway to trigger the Lambda function.

Using Kubernetes on AWS (EKS)

Overview: Amazon Elastic Kubernetes Service (EKS) is a managed Kubernetes service.

Steps to Deploy:

Create EKS Cluster:

sh
eksctl create cluster --name go-app-cluster --region us-west-2

Create Deployment and Service YAML Files:

yaml
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
      - name: go-app
        image: your-docker-image
        ports:
        - containerPort: 8080

yaml
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: go-app
spec:
  type: LoadBalancer
  selector:
    app: go-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Apply Deployment and Service:

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

2. Deploying on Google Cloud Platform (GCP)

Using Google App Engine
- Overview: Google App Engine is a fully managed serverless platform that automatically scales your application.
- Steps to Deploy:
  1. Create App Engine Configuration:
```
yaml
# app.yaml
runtime: go116
handlers:
- url: /.*
  script: auto
```
  2. Deploy Application:
```
sh
gcloud app deploy
```
Using Google Kubernetes Engine (GKE)
- Overview: Google Kubernetes Engine is a managed Kubernetes service that lets you run containerized applications.
- Steps to Deploy:
  1. Create GKE Cluster:
```
sh
gcloud container clusters create go-app-cluster --num-nodes=3
```
  2. Use the same Deployment and Service YAML files as EKS.
  3. Apply Deployment and Service:
```
sh
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
```
Using Cloud Run
- Overview: Cloud Run is a managed compute platform that automatically scales stateless containers.
- Steps to Deploy:
  1. Build and Push Docker Image:
```
sh
gcloud builds submit --tag gcr.io/PROJECT-ID/go-app
```
  2. Deploy to Cloud Run:
```
sh
gcloud run deploy go-app --image gcr.io/PROJECT-ID/go-app --platform managed
```

3. Deploying on Microsoft Azure

Using Azure App Service
- Overview: Azure App Service is a fully managed platform for building, deploying, and scaling web apps.
- Steps to Deploy:
  1. Create a Web App:
```
sh
az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name go-app --runtime "GO|1.14"
```
  2. Deploy Code:
```
sh
az webapp up --name go-app --runtime "GO|1.14"
```
Using Azure Kubernetes Service (AKS)
- Overview: Azure Kubernetes Service is a managed Kubernetes service.
- Steps to Deploy:
  1. Create AKS Cluster:
```
sh
az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 3 --enable-addons monitoring --generate-ssh-keys
```
  2. Use the same Deployment and Service YAML files as EKS.
  3. Apply Deployment and Service:
```
sh
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
```
Using Azure Functions
- Overview: Azure Functions is a serverless compute service that lets you run event-driven code.
- Steps to Deploy:
  1. Create a Function App:
```
sh
func init MyFunctionApp --docker
func new --language go --template "HTTP trigger" --name MyFunction
```
  2. Deploy the Function:
```
sh
func azure functionapp publish myFunctionApp
```

4. Continuous Integration and Continuous Deployment (CI/CD)

CI/CD with GitHub Actions:

Example Workflow for Deploying to AWS:

yaml
name: Deploy to AWS

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

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

    - name: Build
      run: go build -o main .

    - name: Deploy to AWS
      env:
        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        AWS_REGION: us-west-2
      run: |
        zip deployment.zip main
        aws lambda update-function-code --function-name go-lambda --zip-file fileb://deployment.zip

CI/CD with Google Cloud Build:

Example Configuration:

yaml
steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['build', '-o', 'main', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/$PROJECT_ID/go-app', '.']
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['run', 'deploy', 'go-app', '--image', 'gcr.io/$PROJECT_ID/go-app', '--platform', 'managed']

CI/CD with Azure Pipelines:

Example Pipeline for Deploying to AKS:

yaml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UseGoTool@0
  inputs:
    version: '1.16'

- script: |
    go build -o main .
  displayName: 'Build Go application'

- task: AzureCLI@2
  inputs:
    azureSubscription: 'your-subscription-id'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
      kubectl apply -f deployment.yaml
      kubectl apply -f service.yaml
  displayName: 'Deploy to AKS'

By following these guidelines, you can effectively deploy Go applications on AWS, GCP, and Azure, leveraging their respective services to ensure scalability, reliability, and efficient resource utilization.