Golang高级软件工程师招聘 - 100%远程工作 - GreyNoise公司
Golang高级软件工程师招聘 - 100%远程工作 - GreyNoise公司
关于 GreyNoise
有数百家网络安全公司在告诉用户需要担心什么。GreyNoise 是唯一一家告诉用户无需担心什么的网络安全公司。
GreyNoise 是一家早期网络安全产品公司，受到全球安全团队的信任。我们成千上万的免费用户和数十家企业客户使用我们的产品来：
- 了解互联网
- 减少安全运营中心（SOC）的阻力
- 提供关于机会性威胁的洞察
每天，任何一个 SOC 都有成百上千个警报需要调查。GreyNoise 采用数据驱动的方法，从客户已在使用的产品内部着手，提高 SOC 团队的效率。
我们在全球数百个地理位置分布的数据中心运营着一个庞大的被动收集器传感器网络。这些传感器收集并分析“互联网背景噪声”，将其转化为有用的洞察，并通过我们的 Web 界面和集成工具提供给用户。
换句话说，GreyNoise 就像是安全团队的降噪耳机；我们通过消除互联网上各种设备产生的无意义警报，告诉客户无需担心什么。
在 GreyNoise 成为安全社区中无处不在的名字之前，我们不会停止。
你将要做的事情
- 构建和维护一个受数千名个人和组织信任的系统，每小时处理数百万个事件
- 经常主导项目，从构思到交付全程负责
- 为解决网络安全、数据分析和威胁情报领域的未解难题做出贡献
- 帮助我们在 2021 年每月推出 1 个新功能
- 使用框架、SDK 和代码生成器等技术手段，提高其他工程师的工作效率
- 与其他跨职能团队（产品、销售、业务运营等）合作，推动关键战略项目
- 在 GreyNoise 数据的收集、摄取和表示方面发挥重要作用
- 维护由数百台面向互联网的服务器组成的临时集群
- 加入待命轮换，帮助我们改进监控和警报系统
我们的一些工程原则
- 代码的可读性由评审者判断，而非作者
- 技术是廉价的，不要害怕抛弃它
- 编写测试以确保系统的稳定性和可信度
- 不要害怕改变任何已存在的东西
- 慢即是稳，稳即是快
- 区分内部客户和外部客户
- 技术上的妥协是好事
- 实用性和采纳率是所有原型成功标准的一部分
你应具备的条件
5 年以上生产软件工程经验，特别是在以下方面：
- Golang 或 Python（需要深入了解）
- 对 TCP/IP 协议栈有深入理解
- 有基于 SLA 的 SaaS 产品工作经验
- 基础设施即代码（IaC）和 CI/CD 框架
- 软件测试设计和测试方法学
- 构建工具、代码生成器和框架以提高其他工程师的效率
- RPC、事件驱动模式和 REST 微服务模式
- 在公共云环境中操作和维护生产系统
- 处理高流量的 SQL/NoSQL 数据存储
- 客户支持和/或开源社区支持经验，以帮助我们与超过 7000 名成员的社区合作
加分项
- 对分布式系统和互联网的复杂性有浓厚兴趣
- 熟悉流处理和批处理框架
- 熟悉或对互联网大规模扫描或蜜罐技术感兴趣
福利
- 高增长种子阶段初创公司的股权
- 远程优先的文化
- 无限带薪休假
- 医疗、牙科、人寿、视力保险
- 401k 计划
- 设备预算
- 学习和发展预算
- 你真正想穿的优质公司文化衫
GreyNoise 文化
任何伟大公司的标志都是其可感知且凝聚力强的文化。我们文化最重要的支柱如下：
- 保持透明
- 深刻理解客户
- 痛苦可以教会我们一切
- 保持客观冷静
- 对好坏都诚实相告
- 妥协是好事且是必要的
- 识别重要的事，忽略其他一切
- 保持斗志和灵活性
- 没有价值百万的想法，只有价值百万的执行
- 每天都要比前一天更好
为什么你应该在 GreyNoise 工作
- 你喜欢识别和解决难题
- 你乐于将一个想法从概念落实到客户手中
- 你愿意以客观、开放和尊重的方式解释自己的立场并质疑他人
- 你想直接影响用户
- 你想超越自己当前的技能范围
为什么你不应该在 GreyNoise 工作
- 你需要定义明确的流程和职责
- 你更喜欢独自解决问题，而不是与团队合作
- 你喜欢确切地知道每天会发生什么
- 你不想亲自动手实践
- 你想成为房间里最聪明的人
在 LinkedIn 上申请：https://www.linkedin.com/company/greynoise/jobs/（查看更多详情）
直接联系我们：hiring@greynoise.io
更多关于Golang高级软件工程师招聘 - 100%远程工作 - GreyNoise公司的实战教程也可以访问 https://www.itying.com/category-94-b0.html
4 回复
您好，
我已向您发送了一封包含详细信息的电子邮件。请查收。
此致， Frank J
更多关于Golang高级软件工程师招聘 - 100%远程工作 - GreyNoise公司的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html
这是一个非常吸引人的Go高级工程师职位。从技术栈和业务场景来看，GreyNoise正在构建一个高并发、高可靠性的分布式网络安全数据处理系统。以下是一些技术层面的分析和示例：
核心系统架构分析：
从描述看，该系统需要处理每小时数百万事件，涉及数据收集、流处理、存储和API服务。典型的架构会采用微服务模式，Go在这里非常适合。
示例代码 - 数据收集器（简化版）：
package main
import (
"context"
"log"
"net"
"sync"
"time"
"github.com/google/gopacket"
"github.com/google/gopacket/pcap"
)
// Sensor 表示一个数据收集传感器
type Sensor struct {
ID string
Interface string
Filter string
Handler PacketHandler
ctx context.Context
cancel context.CancelFunc
}
type PacketHandler func(packet gopacket.Packet, sensorID string)
// Start 启动传感器数据收集
func (s *Sensor) Start(wg *sync.WaitGroup) error {
defer wg.Done()
handle, err := pcap.OpenLive(s.Interface, 1600, true, pcap.BlockForever)
if err != nil {
return err
}
defer handle.Close()
if err := handle.SetBPFFilter(s.Filter); err != nil {
return err
}
packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
for {
select {
case <-s.ctx.Done():
return nil
case packet := <-packetSource.Packets():
if s.Handler != nil {
s.Handler(packet, s.ID)
}
}
}
}
// 处理TCP/IP协议栈的示例
func analyzeTCPPacket(packet gopacket.Packet) {
if tcpLayer := packet.Layer(gopacket.LayerTypeTCP); tcpLayer != nil {
tcp, _ := tcpLayer.(*gopacket.TCP)
// 分析TCP标志位、端口等
if tcp.SYN && !tcp.ACK {
// 检测SYN扫描
log.Printf("Potential SYN scan from %s", packet.NetworkLayer().NetworkFlow().Src())
}
}
}
示例代码 - 高并发事件处理管道：
package main
import (
"context"
"sync"
"time"
)
// Event 表示安全事件
type Event struct {
ID string
SourceIP net.IP
DestIP net.IP
Timestamp time.Time
Payload []byte
Metadata map[string]interface{}
}
// EventProcessor 事件处理器接口
type EventProcessor interface {
Process(ctx context.Context, event Event) error
}
// Pipeline 构建处理管道
type Pipeline struct {
processors []EventProcessor
bufferSize int
}
func NewPipeline(bufferSize int) *Pipeline {
return &Pipeline{
bufferSize: bufferSize,
processors: make([]EventProcessor, 0),
}
}
// AddProcessor 添加处理器
func (p *Pipeline) AddProcessor(processor EventProcessor) {
p.processors = append(p.processors, processor)
}
// Run 运行处理管道
func (p *Pipeline) Run(ctx context.Context, input <-chan Event) <-chan error {
errChan := make(chan error, p.bufferSize)
go func() {
defer close(errChan)
var wg sync.WaitGroup
for event := range input {
wg.Add(1)
go func(e Event) {
defer wg.Done()
for _, processor := range p.processors {
select {
case <-ctx.Done():
return
default:
if err := processor.Process(ctx, e); err != nil {
errChan <- err
}
}
}
}(event)
}
wg.Wait()
}()
return errChan
}
// 示例处理器 - 威胁情报匹配
type ThreatIntelProcessor struct {
intelDB *ThreatIntelDatabase
}
func (p *ThreatIntelProcessor) Process(ctx context.Context, event Event) error {
// 查询威胁情报数据库
matches, err := p.intelDB.LookupIP(event.SourceIP)
if err != nil {
return err
}
if len(matches) > 0 {
// 标记为已知威胁
event.Metadata["threat_matched"] = true
event.Metadata["threat_info"] = matches
}
return nil
}
示例代码 - 基于SLA的监控中间件：
package main
import (
"context"
"net/http"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
)
var (
requestDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
Name: "http_request_duration_seconds",
Help: "Duration of HTTP requests",
Buckets: prometheus.DefBuckets,
}, []string{"path", "method", "status"})
requestCount = promauto.NewCounterVec(prometheus.CounterOpts{
Name: "http_requests_total",
Help: "Total HTTP requests",
}, []string{"path", "method", "status"})
)
// SLAMiddleware 监控SLA的中间件
func SLAMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
// 包装ResponseWriter以获取状态码
rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
defer func() {
duration := time.Since(start).Seconds()
status := http.StatusText(rw.statusCode)
requestDuration.WithLabelValues(r.URL.Path, r.Method, status).Observe(duration)
requestCount.WithLabelValues(r.URL.Path, r.Method, status).Inc()
// SLA检查：确保95%的请求在100ms内完成
if duration > 0.1 {
log.Printf("SLA warning: request to %s took %.3fs", r.URL.Path, duration)
}
}()
next.ServeHTTP(rw, r)
})
}
type responseWriter struct {
http.ResponseWriter
statusCode int
}
func (rw *responseWriter) WriteHeader(code int) {
rw.statusCode = code
rw.ResponseWriter.WriteHeader(code)
}
基础设施即代码示例（Terraform风格）：
// 使用Go进行基础设施管理的示例结构
package infrastructure
// SensorCluster 定义传感器集群配置
type SensorCluster struct {
Name string
Region string
Size string
Count int
SubnetID string
Tags map[string]string
}
// Deploy 部署传感器集群
func (sc *SensorCluster) Deploy(ctx context.Context, provider CloudProvider) error {
// 创建安全组
sg, err := provider.CreateSecurityGroup(ctx, SecurityGroupConfig{
Name: sc.Name + "-sg",
Description: "Security group for GreyNoise sensors",
Rules: []SecurityRule{
{
Protocol: "tcp",
FromPort: 22,
ToPort: 22,
CIDRBlocks: []string{"10.0.0.0/8"},
},
// 更多规则...
},
})
if err != nil {
return err
}
// 创建实例
for i := 0; i < sc.Count; i++ {
instance, err := provider.CreateInstance(ctx, InstanceConfig{
Name: fmt.Sprintf("%s-%d", sc.Name, i),
InstanceType: sc.Size,
ImageID: "ami-12345678",
SecurityGroups: []string{sg.ID},
SubnetID: sc.SubnetID,
Tags: sc.Tags,
UserData: sc.generateUserData(),
})
if err != nil {
return err
}
// 注册到服务发现
if err := registerToConsul(instance); err != nil {
return err
}
}
return nil
}
测试策略示例：
package processor_test
import (
"context"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestEventProcessor_ConcurrentProcessing(t *testing.T) {
processor := NewEventProcessor()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// 生成测试事件
events := make(chan Event, 1000)
for i := 0; i < 1000; i++ {
events <- Event{
ID: fmt.Sprintf("event-%d", i),
Timestamp: time.Now(),
SourceIP: net.ParseIP(fmt.Sprintf("192.168.1.%d", i%256)),
}
}
close(events)
// 并发处理
errChan := processor.ProcessBatch(ctx, events, 10) // 10个worker
var errors []error
for err := range errChan {
if err != nil {
errors = append(errors, err)
}
}
// 验证SLA：错误率低于0.1%
errorRate := float64(len(errors)) / 1000
assert.Less(t, errorRate, 0.001, "Error rate exceeds SLA")
}
// 集成测试示例
func TestSensorIntegration(t *testing.T) {
// 使用Docker Compose启动测试环境
compose := testutil.NewDockerCompose(t, "docker-compose.test.yml")
defer compose.Down()
require.NoError(t, compose.Up())
// 等待服务就绪
require.NoError(t, testutil.WaitForService("sensor-api:8080", 30*time.Second))
// 执行测试逻辑
client := NewAPIClient("http://localhost:8080")
stats, err := client.GetStats(context.Background())
require.NoError(t, err)
assert.Greater(t, stats.ProcessedCount, 0)
}
这个职位需要处理的技术挑战包括：高并发网络数据处理、分布式系统协调、SLA保证、大规模数据存储和查询。Go的并发模型、性能表现和简洁语法使其成为这类系统的理想选择。候选人需要深入理解TCP/IP协议栈，并能构建可扩展、可维护的生产级系统。
