Golang前后端开发者在波特兰的技术交流与经验分享

Golang前后端开发者在波特兰的技术交流与经验分享 我们的客户希望招聘两名新的资深后端或前端开发人员，他们需要专注于 Golang，因为他们正在用 Go 重写一个 Ruby 应用程序。这不是 UI/UX 或设计师职位。优先考虑能够处理中间件的优秀开发人员/程序员。长期职位，但可能采用合同转正的方式。

客户的解决方案是一个数据平台和服务，允许组织对其软件供应链进行风险管理，并增强其软件基础设施的健壮性和弹性。 我们正在寻找至少拥有 1-2 年专业软件开发经验的人员。 了解以下部分或全部技术（不要求全部掌握）：

  • 测试驱动开发 (TDD) / 行为驱动开发 (BDD)
  • 使用关系数据库的 HTTP Web 服务
  • Golang
  • 包管理器，如 Rubygems、NPM、Maven、Nuget
  • 云服务，如 AWS（客户平台）、Google、Azure
  • 使用 TravisCI、Jenkins 进行持续集成和部署

您将被要求完成的任务：

  • 为新功能编写 Cucumber 测试，编写实现代码以使测试通过
  • 使用 CD 流水线将代码部署到测试环境，涉及 TravisCI、Docker、AWS
  • 为无服务器操作开发 AWS Lambda 函数
  • 午餐学习会 - 参加或就相关技术主题进行非正式演示
  • 代码审查团队成员的 Pull Requests
  • 定期进行结对或群体编程
  • 对缺陷和功能拥有完整的生命周期所有权，从构思到部署给客户

客户能为您提供的：

  • 一个充满挑战和成长的机会
  • 反映您技能和经验的公平薪酬方案
  • 出色完成工作所需的硬件和软件
  • 大部分时间集中办公，部分时间远程工作的环境
  • 灵活的工作时间，但有固定的核心工作时间要求
  • 提供发挥您专业知识的空间，不拘泥于固定的做事方式

您将要做的工作：

  • 用清晰、高性能的代码和配置为产品设计注入活力
  • 使用现代语言和框架处理 Web 应用程序的后端，特别注重模块化和可重用性
  • 与客户、合作伙伴和领导层沟通，定义用例和用户故事
  • 持续编写代码、测试和交付
  • 拥有并发展我们在产品间共享的“风格”
  • 帮助定义我们的技术路线图以及推动整个业务发展的产品未来
  • 与产品团队的其他成员合作，从概念到完成，规划和执行项目
  • 帮助创新和改进我们的产品、信息和交付方式

您需要具备的条件：

  • 出色的设计品味和对细节的关注
  • 精通多种语言（例如 C、C++、Python、Ruby、Java、JavaScript）
  • 具备单元测试、集成测试和功能测试框架及原理的经验
  • 熟悉包管理器、构建工具和持续集成环境
  • 具备 git、GitHub 和 git 工作流的经验
  • 具备数据库技术经验 - SQL/NoSQL、有模式/无模式等
  • 知道如何为工作选择合适的工具，并渴望学习新技能
  • 尊重并热爱“黄金法则”

如果您感兴趣，请联系我 - jeffgrow@serverlogic.com 503-416-8307


更多关于Golang前后端开发者在波特兰的技术交流与经验分享的实战教程也可以访问 https://www.itying.com/category-94-b0.html

5 回复

你好 @jjgrow

我可以提供帮助。

邮件已发送，请查收。

此致 Frank

更多关于Golang前后端开发者在波特兰的技术交流与经验分享的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


招聘前端开发人员总是件棘手的事。我是一名自由职业开发者，经常被问及如何招聘开发人员。我决定就此话题写一篇博客文章。希望你们会觉得有用。

如果您正在寻找前端开发人员，我建议您查看这篇文章 https://www.cleveroad.com/blog/how-to-hire-front-end-developers，以了解您应该对不同级别（初级、中级或高级）的开发人员有何期望。这样，您就能轻松找到最适合您的人选。

你好 Jeff，

分享我们的一项案例研究，其中我们将 Rakuten Viki 平台从 ROR 迁移到了 Golang。

Gophers Lab

为 Rakuten 的流媒体网站 Viki 现代化遗留微服务

为 Rakuten 的流媒体网站 Viki 现代化遗留微服务…

预计阅读时间：1 分钟

请查阅，并告知我们是否可以交流一下。

祝好， Chirag

这是一个非常典型的Go语言后端开发职位描述，专注于从Ruby迁移到Go的技术栈转型。以下是针对该职位要求的技术分析和示例代码：

核心Go技术栈分析

该职位主要涉及Go Web服务、中间件开发和云原生部署。以下是关键技术的代码示例：

1. HTTP Web服务与中间件开发

package main

import (
    "log"
    "net/http"
    "time"
    
    "github.com/gorilla/mux"
    "github.com/rs/cors"
)

// 自定义中间件示例
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("Started %s %s", r.Method, r.URL.Path)
        
        // 调用下一个处理器
        next.ServeHTTP(w, r)
        
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
    })
}

// 认证中间件
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        // 验证token逻辑
        next.ServeHTTP(w, r)
    })
}

func main() {
    r := mux.NewRouter()
    
    // 应用中间件链
    r.Use(loggingMiddleware)
    r.Use(authMiddleware)
    
    // API路由
    r.HandleFunc("/api/users", getUsers).Methods("GET")
    r.HandleFunc("/api/users/{id}", getUser).Methods("GET")
    r.HandleFunc("/api/users", createUser).Methods("POST")
    
    // 配置CORS
    c := cors.New(cors.Options{
        AllowedOrigins: []string{"*"},
        AllowedMethods: []string{"GET", "POST", "PUT", "DELETE"},
    })
    
    handler := c.Handler(r)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", handler))
}

2. 数据库层实现（使用GORM）

package models

import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "time"
)

type User struct {
    ID        uint           `gorm:"primaryKey" json:"id"`
    Name      string         `json:"name"`
    Email     string         `gorm:"uniqueIndex" json:"email"`
    CreatedAt time.Time      `json:"created_at"`
    UpdatedAt time.Time      `json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}

type UserRepository struct {
    db *gorm.DB
}

func NewUserRepository(dsn string) (*UserRepository, error) {
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return nil, err
    }
    
    // 自动迁移
    db.AutoMigrate(&User{})
    
    return &UserRepository{db: db}, nil
}

func (r *UserRepository) CreateUser(user *User) error {
    return r.db.Create(user).Error
}

func (r *UserRepository) GetUserByID(id uint) (*User, error) {
    var user User
    err := r.db.First(&user, id).Error
    return &user, err
}

func (r *UserRepository) UpdateUser(user *User) error {
    return r.db.Save(user).Error
}

3. AWS Lambda函数示例

package main

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

type Request struct {
    Action string `json:"action"`
    Data   string `json:"data"`
}

type Response struct {
    StatusCode int    `json:"statusCode"`
    Body       string `json:"body"`
}

func handler(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    var req Request
    if err := json.Unmarshal([]byte(request.Body), &req); err != nil {
        return events.APIGatewayProxyResponse{
            StatusCode: 400,
            Body:       "Invalid request body",
        }, nil
    }
    
    // 处理业务逻辑
    result := processRequest(req)
    
    response, _ := json.Marshal(result)
    
    return events.APIGatewayProxyResponse{
        StatusCode: 200,
        Headers: map[string]string{
            "Content-Type": "application/json",
        },
        Body: string(response),
    }, nil
}

func processRequest(req Request) map[string]interface{} {
    return map[string]interface{}{
        "action":  req.Action,
        "result":  "processed",
        "message": "Request handled successfully",
    }
}

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

4. 测试驱动开发示例

package main

import (
    "testing"
    "net/http"
    "net/http/httptest"
)

func TestGetUsers(t *testing.T) {
    req, err := http.NewRequest("GET", "/api/users", nil)
    if err != nil {
        t.Fatal(err)
    }
    
    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(getUsers)
    
    handler.ServeHTTP(rr, req)
    
    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }
    
    expected := `[{"id":1,"name":"John"}]`
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

// BDD风格测试使用Ginkgo和Gomega
/*
var _ = Describe("User API", func() {
    var (
        server *httptest.Server
        client *http.Client
    )
    
    BeforeEach(func() {
        server = httptest.NewServer(createRouter())
        client = server.Client()
    })
    
    AfterEach(func() {
        server.Close()
    })
    
    It("should return users list", func() {
        resp, err := client.Get(server.URL + "/api/users")
        Expect(err).NotTo(HaveOccurred())
        Expect(resp.StatusCode).To(Equal(http.StatusOK))
    })
})
*/

5. Docker部署配置

# Dockerfile
FROM golang:1.19-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main .

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
COPY --from=builder /app/.env .

EXPOSE 8080
CMD ["./main"]

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/dbname
    depends_on:
      - db
  db:
    image: postgres:14
    environment:
      POSTGRES_DB: dbname
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

6. 持续集成配置（.travis.yml）

language: go
go:
  - "1.19"

services:
  - docker
  - postgresql

env:
  global:
    - GO111MODULE=on

before_script:
  - psql -c 'create database testdb;' -U postgres
  - go mod download

script:
  - go test -v ./...
  - go build -v ./...

after_success:
  - docker build -t myapp:$TRAVIS_COMMIT .
  - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
  - docker push myapp:$TRAVIS_COMMIT

deploy:
  provider: elasticbeanstalk
  access_key_id: $AWS_ACCESS_KEY
  secret_access_key: $AWS_SECRET_KEY
  region: us-west-2
  app: my-go-app
  env: my-go-app-prod
  bucket_name: elasticbeanstalk-us-west-2-123456789
  on:
    branch: main

技术要点总结

  1. 中间件开发：Go的net/http包和第三方库（如gorilla/mux）提供了强大的中间件支持
  2. 数据库集成：使用GORM或sqlx进行数据库操作，支持PostgreSQL等关系数据库
  3. 测试覆盖：内置testing包配合第三方测试框架（testify、ginkgo）
  4. 云原生部署：Docker容器化，AWS Lambda无服务器架构
  5. CI/CD流水线：TravisCI与Docker集成实现自动化部署

这个职位要求的技术栈在波特兰的Go开发社区中非常典型，特别是涉及Ruby到Go迁移的项目经验。

回到顶部