experto-go

Files (1)

• SKILL.md

SKILL.md (first lines)

## Cuando usar

Usa esta skill para microservicios en Go, concurrencia con goroutines/channels y gRPC.
Cubre worker pools, fan-out/fan-in, rate limiter, context, HTTP server y errores.
Para REST/OpenAPI, Docker/K8s o CI/CD usa `diseno-api`, `experto-docker` o `patrones-despliegue`.
No uses esta skill fuera del stack Go.

## Project Structure

```
service/
├── cmd/
│   └── server/
│       └── main.go           # Entry point
├── internal/
│   ├── handler/              # HTTP/gRPC handlers
│   ├── service/              # Business logic
│   ├── repository/           # Data access
│   ├── model/                # Domain models
│   └── config/               # Configuration
├── pkg/                      # Public reusable packages
├── api/
│   └── proto/                # Protobuf definitions
├── migrations/
├── go.mod
└── go.sum
```

## Concurrency Patterns

### Worker Pool

```go
func processItems(ctx context.Context, items []Item) error {
    const maxWorkers = 10

    g, ctx := errgroup.WithContext(ctx)
    itemsCh := make(chan Item)

    // Producer
    g.Go(func() error {
        defer close(itemsCh)
        for _, item := range items {
            select {
            case <-ctx.Done():
                return ctx.Err()
            case itemsCh <- item:
            }
        }
        return nil
    })

    // Workers
    for i := 0; i < maxWorkers; i++ {
        g.Go(func() error {
            for item := range itemsCh {
                if err := process(ctx, item); err != nil {
                    return err
                }
            }
            return nil
        })
    }

    return g.Wait()
}
```

### Fan-Out/Fan-In

```go
func fanOutFanIn(ctx context.Context, input <-chan Data, workers int) <-chan Result {
    results := make(chan Result)
    var wg sync.WaitGroup

    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for data := range input {
                select {
                case <-ctx.Done():
                    return
                case results <- transform(data):
                }
            }
        }()
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    return results
}
```

### Rate Limiter

```go
type RateLimiter struct {
    ticker *time.Ticker
    tokens chan struct{}
}

func NewRateLimiter(rps int) *RateLimiter {
    rl := &RateLimiter{
        ticker: time.NewTicker(time.Second / time.Duration(rps)),
        tokens: make(chan struct{}, rps),
    }
    go func() {
        for range rl.ticker.C {
            select {
            case rl.tokens <- struct{}{}:
            default:
            }
        }
    }()

From tontojil/PerfeckCode, MIT.

More from tontojil/PerfeckCode