高薪招聘Golang开发工程师和架构师参与优质项目

高薪招聘Golang开发工程师和架构师参与优质项目 我们正在寻找才华横溢的 Go 开发者和架构师，帮助我们构建一个尖端的金融科技应用程序，该应用将彻底改变房地产租赁和保险行业。

如果您有兴趣申请此职位，请发送电子邮件至 peter.byrne@dresslerconsulting.com。

公司简介

客户是一家金融科技公司，为住宅和商业房地产专业人士及其居民和租户提供创新的保险产品和金融解决方案。凭借在房地产、风险和金融领域的数据和行业专业知识，该公司通过消除租赁过程中的风险并同时提高其效率，优化了房东、租赁人员、经纪人和租户之间的关系。

项目描述

金融/保险科技旨在使用最新技术实现完全数字化 技术栈主要由 React 和 Node.js 组成 将单体应用迁移到事件驱动的微服务架构，全部托管在 AWS 上

技术栈：

  • 8 年以上总工作经验。
  • Go/Golang (3 年以上)
  • 分布式系统和微服务：5 年（必需）
  • Java, C++, C# .NET
  • Node JS
  • 关系型数据库和信息架构
  • gRPC
  • GraphQL
  • PostgreSQL
  • 消息系统，如 Kafka、NATS 和 MQTT
  • Docker 和基于容器的微服务
  • 使用 kubectl 和 Kubernetes API 概念的 Kubernetes
  • 软件架构、数据结构、现代设计模式和网络协议
  • 源代码控制经验，包括分支、合并和变基
  • 调试技能
  • Linux 操作系统基础知识
  • 优先考虑具备以下资格：
    • 通过命令行和 AWS 控制台使用 AWS
    • CI/CD 流水线自动化工具（Bamboo、Jenkins 等）
    • 使用 Swagger/OpenAPI 进行 API 设计和文档编写
    • 多租户应用程序的实施和维护
    • Websockets、GraphQL 订阅和其他流式传输技术

职责

  • 在敏捷环境中工作
  • 与其他软件工程和设计团队、产品负责人和经理以及业务利益相关者合作，实现新功能
  • 使用 Go 及相关框架（Express.js、Nest.js）开发应用程序的后端
  • 创建全面的微服务架构
  • 开发功能完整的应用程序组件，编写干净、可测试的代码
  • 执行测试和调试，以最大限度地提高应用程序的效率和性能
  • 执行单元测试和集成测试

更多关于高薪招聘Golang开发工程师和架构师参与优质项目的实战教程也可以访问 https://www.itying.com/category-94-b0.html

4 回复

您好，

希望您一切顺利。

我对您发布的职位很感兴趣，请通过 seth.c@talentsfromindia.com 与我联系。

期待很快能与您合作。

此致！

更多关于高薪招聘Golang开发工程师和架构师参与优质项目的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你好，

我很乐意为你提供帮助。

如需进一步详细讨论，请通过邮件 garry@cisinlabs.com 或 Skype: cis.garry 联系我。

期待你的回复。

谢谢。

你好 Peter，

如果你还在寻找帮助，我对这个职位很感兴趣。 你可以通过 andrewjohnson56782@gmail.com 联系我。 祝好，并祝你度过愉快的一天， Andrew

这是一个非常典型的Go微服务架构职位，技术栈要求全面且符合当前金融科技领域的主流实践。以下是一些技术角度的分析：

1. 技术栈匹配度分析 这个职位对Go开发者的要求很典型：3年以上Go经验，加上分布式系统背景。技术栈中提到的gRPC、Kafka、Docker/Kubernetes都是Go微服务开发的标配。

2. 架构迁移建议 从单体迁移到事件驱动微服务，Go在这方面有天然优势。以下是一个简单的gRPC服务示例：

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/your/proto"
)

type server struct {
    pb.UnimplementedInsuranceServiceServer
}

func (s *server) ProcessClaim(ctx context.Context, req *pb.ClaimRequest) (*pb.ClaimResponse, error) {
    // 业务逻辑处理
    return &pb.ClaimResponse{
        ClaimId:   req.ClaimId,
        Status:    "PROCESSING",
        Timestamp: time.Now().Unix(),
    }, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    
    s := grpc.NewServer()
    pb.RegisterInsuranceServiceServer(s, &server{})
    
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

3. 事件驱动架构实现 使用Kafka进行事件处理的典型模式：

package main

import (
    "context"
    "encoding/json"
    "log"

    "github.com/segmentio/kafka-go"
)

type RentalEvent struct {
    EventType string      `json:"event_type"`
    TenantID  string      `json:"tenant_id"`
    PropertyID string     `json:"property_id"`
    Timestamp int64       `json:"timestamp"`
    Data      interface{} `json:"data"`
}

func produceKafkaEvent(event RentalEvent) error {
    conn, err := kafka.DialLeader(context.Background(), "tcp", "localhost:9092", "rental-events", 0)
    if err != nil {
        return err
    }
    defer conn.Close()

    eventJSON, _ := json.Marshal(event)
    
    _, err = conn.WriteMessages(
        kafka.Message{Value: eventJSON},
    )
    return err
}

func consumeKafkaEvents() {
    r := kafka.NewReader(kafka.ReaderConfig{
        Brokers:   []string{"localhost:9092"},
        Topic:     "rental-events",
        Partition: 0,
        MinBytes:  10e3,
        MaxBytes:  10e6,
    })
    defer r.Close()

    for {
        m, err := r.ReadMessage(context.Background())
        if err != nil {
            log.Printf("error reading message: %v", err)
            continue
        }
        
        var event RentalEvent
        json.Unmarshal(m.Value, &event)
        
        // 处理事件
        processEvent(event)
    }
}

4. 多租户实现模式 对于金融科技应用，多租户是关键需求：

package main

import (
    "context"
    "database/sql"
    "fmt"
)

type TenantAwareService struct {
    db *sql.DB
}

func (s *TenantAwareService) GetTenantData(ctx context.Context, tenantID string) ([]DataRecord, error) {
    // 使用租户ID进行数据隔离
    query := `
        SELECT id, data_field 
        FROM tenant_data 
        WHERE tenant_id = $1 
        AND is_active = true
    `
    
    rows, err := s.db.QueryContext(ctx, query, tenantID)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var results []DataRecord
    for rows.Next() {
        var record DataRecord
        if err := rows.Scan(&record.ID, &record.DataField); err != nil {
            return nil, err
        }
        results = append(results, record)
    }
    
    return results, nil
}

// 使用中间件进行租户隔离
func TenantMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tenantID := r.Header.Get("X-Tenant-ID")
        if tenantID == "" {
            http.Error(w, "Tenant ID required", http.StatusBadRequest)
            return
        }
        
        ctx := context.WithValue(r.Context(), "tenantID", tenantID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

5. 测试策略 对于金融应用，测试至关重要：

package service

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

type MockDatabase struct {
    mock.Mock
}

func (m *MockDatabase) Query(query string, args ...interface{}) ([]Record, error) {
    args := m.Called(query, args)
    return args.Get(0).([]Record), args.Error(1)
}

func TestInsuranceService(t *testing.T) {
    mockDB := new(MockDatabase)
    service := NewInsuranceService(mockDB)
    
    expectedRecords := []Record{{ID: "123", Premium: 1000}}
    mockDB.On("Query", mock.Anything, mock.Anything).Return(expectedRecords, nil)
    
    result, err := service.CalculatePremium("property-123")
    
    assert.NoError(t, err)
    assert.Equal(t, 1000, result.Premium)
    mockDB.AssertExpectations(t)
}

这个职位要求的技术栈非常符合现代Go微服务开发的最佳实践，特别是在金融科技领域需要的高并发、高可靠性和数据一致性方面，Go的表现尤为出色。

回到顶部