Warum noch ein Go-Tutorial

AWS hat in letzter Zeit mehrere Dienste und Laufzeiten eingestellt. Wie wir mit der Einstellung unseres beliebten CodeCommit und anderer wichtiger Dienste gesehen haben, wird Go1.x für AWS Lambda-Funktionen nicht mehr unterstützt.

Wenn Sie versuchen, die meisten veralteten Tutorials bereitzustellen, können Fehler wie dieser auftreten:

Resource creation Initiated    
CREATE_FAILED                    AWS::Lambda::Function            DemoFunction                     
                                   Resource handler returned message: 
                                   "The runtime parameter of go1.x is no longer supported for 
                                   creating or updating AWS Lambda functions. We recommend you 
                                   use a supported runtime while creating or updating functions. 
                                   (Service: Lambda, Status Code: 400, Request ID:  
                                   81f1f708-0a7a-40d0-8442-b9c16510d01f)" 
ROLLBACK_IN_PROGRESS             AWS::CloudFormation::Stack       lambda-go-gorilla                
                                   The following resource(s) failed to create: 
                                   [DemoFunction]. Rollback requested by user.

Die wichtigste Erkenntnis ist, dass die einzige Konstante in der Software der Wandel ist. Es gibt jedoch einige zeitlose Prinzipien, die wir immer im Auge behalten sollten:

Um dieses Problem zu beheben, habe ich beschlossen, ein aktuelles Repository mit der gesamten Infrastruktur zu erstellen, die für die Bereitstellung einer Go-Anwendung erforderlich ist. Es stehen zwei Optionen zur Verfügung:

1. Bereitstellung mit Fargate unter Verwendung von Docker-Containern.
2. Bereitstellung mit dem SAM-Framework auf AWS.

Sie können das Repository auf GitHub hier finden.

Zeitlose Prinzipien in der Softwareentwicklung

• Infrastruktur als Code ist unerlässlich.
• Gute Namenskonventionen in Software sind entscheidend.
• Testen Sie immer Ihre Logik.
• Verfügbarkeit und Skalierbarkeit
• Deployment Pipeline als Mechanismus zur Automatisierung des Softwarebereitstellungsprozesses.
• Beobachtbarkeit ist obligatorisch.
• Sicherheit ist ein erstklassiger Bürger bei Cloud-nativen Anwendungen.
• Go ist eine hervorragende Option zum Erstellen von APIs.

Infrastruktur als Code ist unerlässlich

Eine unveränderliche Infrastruktur ermöglicht es uns, auf einer höheren Ebene zu erklären, was wir wollen, und stellt sicher, dass Entwicklungs- und Produktionsumgebungen so nah wie möglich bleiben. Zum Beispiel:

CompoundingFunction:
  Type: AWS::Serverless::Function
  Metadata:
    BuildMethod: makefile
  Properties:
    FunctionName: CompoundingFunction
    Architectures: ["arm64"]
    Handler: bootstrap
    Runtime: provided.al2
    CodeUri: ./functions/CompoundingFunction/
    MemorySize: 512
    Timeout: 10
    Environment:
      Variables:
        COMPOUNDING_TABLE_NAME: !Ref CompoundingTable
    Policies:
      - DynamoDBCrudPolicy:
          TableName: !Ref CompoundingTable
    Events:
      ApiGatewayPost:
        Type: Api
        Properties:
          RestApiId: !Ref ApiGateway
          Path: /compounding
          Method: POST

Gute Namenskonventionen in der Software sind der Schlüssel

Scheuen Sie sich nicht vor einem Refactoring, wenn Sie über eine gute Testsuite verfügen. Refactoring ist eine wesentliche Aktivität in der Softwareentwicklung. Namen sind wichtig, da sie überall in Modulen, Funktionen, Paketen, Variablen usw. vorkommen.

package main

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

// Response is the structure for the response JSON
type Response struct {
    Message      string    `json:"message"`
    GainsPerYear []float64 `json:"gainsPerYear"`
}

type Request struct {
    Principal  float64 `json:"principal"`
    AnnualRate float64 `json:"annualRate"`
    Years      int     `json:"years"`
}

func HelloHandler(ctx context.Context, event events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    var req Request
    err := json.Unmarshal([]byte(event.Body), &req)
    if err != nil {
        return createResponse(400, "Invalid request body")
    }
    fmt.Println("Request", req)
    gainsPerYear := CalculateCompoundInterest(req.Principal, req.AnnualRate, req.Years)
    fmt.Println(gainsPerYear)
    response := Response{
        Message:      "Calculation successful",
        GainsPerYear: gainsPerYear,
    }

    body, err := json.Marshal(response)
    if err != nil {
        return createResponse(500, "Error marshalling response")
    }

    return createResponse(200, string(body))
}

func createResponse(statusCode int, body string) (events.APIGatewayProxyResponse, error) {
    return events.APIGatewayProxyResponse{
        StatusCode: statusCode,
        Body:       body,
        Headers:    map[string]string{"Content-Type": "application/json"},
    }, nil
}

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

Testen Sie immer Ihre Logik

In serverlosen Anwendungen sind Unit-Tests wichtig, aber vergessen Sie nicht, auch Integrationstests einzubeziehen, da die meisten dieser Anwendungen auf Integrationen und Richtlinien angewiesen sind, um Geschäftsprobleme zu lösen.

func TestCalculateCompoundInterest(t *testing.T) {
    principal := 100000000.0
    annualRate := 10.0
    years := 10

    result := CalculateCompoundInterest(principal, annualRate, years)
    lastElement := round(result[len(result)-1], 2)

    expected := round(259374246.01, 2)
    if !reflect.DeepEqual(lastElement, expected) {
        t.Errorf("Expected %v, but got %v", expected, lastElement)
    }
}

Verfügbarkeit und Skalierbarkeit

Serverlose Architekturen sind standardmäßig hochverfügbar und ereignisgesteuert, wodurch die meisten betrieblichen Aufgaben entfallen. Wenn Sie sich jedoch für ECS und Container entscheiden, ist es wichtig, einen Load Balancer einzubinden, um den Datenverkehr auf Ihre Server zu verteilen und so sowohl Verfügbarkeit als auch Skalierbarkeit sicherzustellen.

  CompoundingLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Name: compounding-nlb
      Scheme: internet-facing
      Type: network
      Subnets:
        - !Ref PublicSubnetOne
        - !Ref PublicSubnetTwo

Bereitstellungspipeline

Eine Bereitstellungspipeline automatisiert den Softwarebereitstellungsprozess. Wir haben ein Makefile erstellt, um diesen Prozess zu vereinfachen und es einfacher zu machen, sich wiederholende Aufgaben mit einem einzigen Befehl bereitzustellen und auszuführen. Dieser Ansatz erhöht die Effizienz und Konsistenz Ihres Bereitstellungsworkflows.

Beobachtbarkeit ist obligatorisch

Stellen Sie sicher, dass Ablaufverfolgung, Protokollierung und Metriken vorhanden sind. Bei serverlosen Anwendungen ist die Aktivierung dieser Funktionen so einfach wie das Hinzufügen von Tracing: Active. Die Möglichkeit, alle Protokolle an einem zentralen Ort wie CloudWatch einzusehen und die Interaktionen des Dienstes zu überwachen, ist von unschätzbarem Wert.

Sicherheit ist bei Cloud-nativen Anwendungen oberstes Gebot

Sicherheit ist bei allen Anwendungen von größter Bedeutung. Die Verwendung von Amazon Cognito bietet eine robuste Benutzerauthentifizierung, während API-Schlüssel eine zusätzliche Kontroll- und Autorisierungsebene hinzufügen und sicherstellen, dass nur autorisierte Clients auf Ihre APIs zugreifen können.

Auth:
  DefaultAuthorizer: CompoundingAuthorizer
  Authorizers:
    CompoundingAuthorizer:
      UserPoolArn:  XXXX
    LambdaTokenAuthorizer:
      FunctionArn: !GetAtt LambdaTokenAuthorizerFunction.Arn
      FunctionPayloadType: REQUEST
      Identity:
        Headers:
          - Authorization
        ReauthorizeEvery: 100
  AddDefaultAuthorizerToCorsPreflight: false

Weisen Sie jedem Dienst, Benutzer und jeder Komponente die minimal erforderlichen Berechtigungen zu, um die Angriffsfläche zu verringern und unbefugten Zugriff zu verhindern. Prinzip der geringsten Rechte:

      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref CompoundingTable

Referenzen

1. Terraform in Aktion – Praktische Anwendungen und Strategien zur Implementierung von Terraform, einem Tool zum Aufbau, zur Änderung und zur Verwaltung von Infrastruktur.
2. Continuous-Delivery-Pipelines

Abschluss

Software entwickelt sich ständig weiter, und obwohl sich einige Tools und Praktiken ändern werden, bleiben die Grundprinzipien dieselben. Wir brauchen eine unveränderliche Infrastruktur, CI/CD, gute Namenskonventionen, eine robuste Teststrategie, Sicherheit in unseren APIs und Effizienz in unseren Anwendungen. Aus diesem Grund habe ich beschlossen, dieses Projekt serverlos neu zu erstellen.

Es gab noch nie einen besseren Zeitpunkt, Ingenieur zu werden und durch Software Werte in der Gesellschaft zu schaffen.

• LinkedIn
• Twitter
• GitHub

Wenn Ihnen die Artikel gefallen haben, besuchen Sie meinen Blog jorgetovar.dev