Cos'è l'architettura a strati e come è stata organizzata nel tuo progetto?
Golang
Quale posizione stai considerando ora per te, cosa sarebbe interessante?
Cos'è il grooming e in cosa si differenzia dalla pianificazione?
Qual è la limitazione di un semaforo e di un canale con buffer come soluzioni per limitare le richieste parallele?
Quale formato di lavoro stai considerando?
Compito: c'è un servizio con un limite di 5 richieste parallele a LLM. Alla sesta richiesta si riceve un 429. Come risolvere questo problema concettualmente?
Quali sono le tue aspettative finanziarie?
/* C'è un'applicazione con architettura a microservizi. Un microservizio può essere astratto tramite l'interfaccia Backend. Per accedere a un'istanza di microservizio, si può usare il tipo BackendImpl, che è già implementato. Ogni microservizio ha diverse decine di istanze in esecuzione, ognuna accessibile tramite il proprio indirizzo addr. Tuttavia, le singole istanze del microservizio non sono affidabili: potrebbero fallire, essere inaccessibili o sovraccariche. Per questo, devi implementare il tipo Balancer, che implementa anche l'interfaccia Backend e effettua il bilanciamento del carico lato client tra le istanze del microservizio, scegliendo ogni volta l'istanza **meno caricata**. */ type Request interface{} type Response interface{} type Backend interface { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr contiene ip:porta di una specifica istanza func NewBackend(addr string) *BackendImpl type Balancer struct { //TODO } var _ Backend = &Balancer{} // addrs contengono gli indirizzi di tutte le istanze bilanciate func NewBalancer(addrs []string) *Balancer { //TODO }
C'è qualche scadenza?
/* Una stringa di caratteri viene data. Trovare il numero di coppie di indici i e j (i <= j), tra cui non ci sono caratteri ripetuti. Per la stringa "aba" la risposta è 5: possono essere ASCII [0, 0] ("a") [0, 1] ("ab") [1, 1] ("b") [1, 2] ("ba") [2, 2] ("a") */
Cosa sai del programma multitrack di Yandex?
Come appare una funzionalità e arriva fino alla vendita: pianificazione, sviluppo, test, revisione del codice, rilascio, rollback?
tipo Response interfaccia {} tipo Backend interfaccia { Invoke(ctx context.Context, req Request) (Response, error) } var _ Backend = &BackendImpl{} // addr contiene ip:port di una specifica istanza func NewBackend(addr string) *BackendImpl type Balancer struct { // TODO backends []*BackendImpl index int mu sync.Mutex } var _ Backend = &Balancer{} func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) { se len(b.backends) == 0 { return nil, fmt.Errorf("Il numero di backends nel slice è 0") } b.mu.Lock() index := b.index se b.index + 1 == len(b.backends) { b.index = 0 index = 0 } b.mu.Unlock() resp, err := b.backends[index].Invoke(ctx, req) return resp, err } // addrs contiene gli indirizzi di tutte le istanze bilanciate func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImpl, len(addrs))
Come hai integrato LLM in un progetto di crediti? Raccontalo in generale.
/** :-))) :-(( "ab :-)" = "ab " "ab :-)))" = "ab " "ab :-)))(" = "ab (" "ab ):-)" = "ab )" ":-)" = "" **/ func deleteP(str string) string { }
/* Viene fornita una stringa di caratteri. Trovare il numero di coppie di indici i e j (i <= j), tra cui non ci sono caratteri ripetuti. Per la stringa "aba" la risposta è 5: [0, 0] ("a") [0, 1] ("ab") [1, 1] ("b") [1, 2] ("ba") [2, 2] ("a") */
Come verifica JWT la sua autenticità? Come si assicura che il token non sia falsificato?
Come si lavora sull'architettura — c'è un architetto nel team, piattaforma, comitato?
type Balancer struct { // TODO backends []*BackendImpl index int mu sync.Mutex N int K time.Duration } var _ Backend = &Balancer{} func (b *Balancer) Invoke(ctx context.Context, req Request) (Response, error) { if len(b.backends) == 0 { return nil, fmt.Errorf("Numero di backends nel slice 0") } b.mu.Lock() index := b.index for b.backends[index].banned { b.index = (b.index + 1) % len(b.backends) index = b.index } b.index = (b.index + 1) % len(b.backends) b.mu.Unlock() backend := b.backends[index] resp, err := backend.Backend.Invoke(ctx, req) if err != nil && backend.countErrors < b.N { backend.mu.Lock() backend.countErrors += 1 if backend.countErrors == b.N { backend.banned = true go func() { time.Sleep(b.K) backend.mu.Lock() defer backend.mu.Unlock() backend.banned = false backend.countErrors = 0 }() } backend.mu.Unlock() } return resp, err } // addrs contengono gli indirizzi di tutte le istanze bilanciate func NewBalancer(addrs []string) *Balancer { // TODO backends := make([]*BackendImplF, len(addrs)) for _, addr := range addrs { implF := BackendImplF{ Backend: NewBackend(addr), } backends = append(backends, &implF) } }
Hai esperienza nel supporto o nello sviluppo di sistemi distribuiti?