Golang基础架构软件工程师职位（洛杉矶或远程）

这是一个非常不错的Go语言基础设施工程师职位机会。Dollar Shave Club的基础设施团队在Go和Kubernetes领域有着深厚的技术积累，从他们开源的几个项目就能看出技术实力。

以他们维护的acyl项目（一个Kubernetes命名空间管理工具）为例，可以看到典型的Go语言基础设施代码风格：

// 类似acyl项目中处理Kubernetes资源的模式
package main

import (
    "context"
    "fmt"
    "time"
    
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
)

type NamespaceManager struct {
    clientset *kubernetes.Clientset
}

func NewNamespaceManager() (*NamespaceManager, error) {
    config, err := rest.InClusterConfig()
    if err != nil {
        return nil, fmt.Errorf("failed to get in-cluster config: %v", err)
    }
    
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        return nil, fmt.Errorf("failed to create clientset: %v", err)
    }
    
    return &NamespaceManager{clientset: clientset}, nil
}

func (nm *NamespaceManager) CreateNamespace(ctx context.Context, name string) error {
    ns := &v1.Namespace{
        ObjectMeta: metav1.ObjectMeta{
            Name: name,
            Labels: map[string]string{
                "managed-by": "acyl",
                "created-at": time.Now().Format(time.RFC3339),
            },
        },
    }
    
    _, err := nm.clientset.CoreV1().Namespaces().Create(ctx, ns, metav1.CreateOptions{})
    if err != nil {
        return fmt.Errorf("failed to create namespace %s: %v", name, err)
    }
    
    return nil
}

func (nm *NamespaceManager) CleanupOldNamespaces(ctx context.Context, maxAge time.Duration) error {
    namespaces, err := nm.clientset.CoreV1().Namespaces().List(ctx, metav1.ListOptions{
        LabelSelector: "managed-by=acyl",
    })
    if err != nil {
        return fmt.Errorf("failed to list namespaces: %v", err)
    }
    
    for _, ns := range namespaces.Items {
        creationTime := ns.CreationTimestamp.Time
        if time.Since(creationTime) > maxAge {
            err := nm.clientset.CoreV1().Namespaces().Delete(ctx, ns.Name, metav1.DeleteOptions{})
            if err != nil {
                fmt.Printf("Failed to delete namespace %s: %v\n", ns.Name, err)
            }
        }
    }
    
    return nil
}

他们的guardian项目（一个基于角色的访问控制代理）展示了Go在API网关和认证授权方面的应用：

// 类似guardian中的中间件处理模式
package main

import (
    "net/http"
    "strings"
    
    "github.com/dgrijalva/jwt-go"
)

type RBACMiddleware struct {
    secretKey []byte
}

func NewRBACMiddleware(secretKey string) *RBACMiddleware {
    return &RBACMiddleware{
        secretKey: []byte(secretKey),
    }
}

func (m *RBACMiddleware) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        if authHeader == "" {
            http.Error(w, "Authorization header required", http.StatusUnauthorized)
            return
        }
        
        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
        claims := &jwt.StandardClaims{}
        
        token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
            return m.secretKey, nil
        })
        
        if err != nil || !token.Valid {
            http.Error(w, "Invalid token", http.StatusUnauthorized)
            return
        }
        
        // 检查角色权限
        if !m.hasPermission(claims.Subject, r.URL.Path, r.Method) {
            http.Error(w, "Insufficient permissions", http.StatusForbidden)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

func (m *RBACMiddleware) hasPermission(userID, path, method string) bool {
    // 实现具体的RBAC逻辑
    return true
}

这个职位要求工程师深入参与Kubernetes operator开发、CI/CD流水线工具构建，以及云原生基础设施的维护。从他们的开源项目看，团队代码质量很高，遵循Go最佳实践，包括清晰的错误处理、上下文传播和并发安全设计。

申请者需要熟练掌握client-go、controller-runtime等Kubernetes Go客户端库，以及在实际生产环境中部署和维护Go服务的经验。他们的技术栈明显偏向云原生生态，涉及服务网格、可观测性工具链等基础设施组件。