Sirva o roteador em uma CPU, com a transferência para uma pessoa dentro da rota

Cerca de 22 minutos min de leitura, com 2 exemplos em 5 seções.

Edição 2026.11.9 Exemplos aprovados em 20 de nov de 2026 36 de 36 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.9. Leia o original

Ao final deste capítulo, você poderá servir o roteador como um único endpoint POST /route que devolve, para cada mensagem, uma equipe, uma confiança e um sinalizador de transferência. Você também poderá testar se a rota nunca devolve uma equipe para uma mensagem que foi transferida.

A rota é o ponto em que a regra de transferência se sustenta ou falha. O capítulo 1 definiu as equipes, e o capítulo 5 construiu uma cabeça que devolve uma equipe e uma confiança em uma única passagem direta, além de ter escolhido o limiar que decide quando uma mensagem vai para uma pessoa. Este capítulo coloca esse modelo atrás de uma rota HTTP, que é por onde o software da caixa de entrada envia uma mensagem e recebe de volta uma equipe ou uma transferência.

Se quem chama a rota puder obter uma equipe para uma mensagem que o roteador sinalizou, o sinalizador não faz nada, por mais cuidadosamente que o capítulo 5 tenha escolhido seu limiar. Por isso, a rota calcula ela mesma o sinalizador, a partir da mesma resposta que fornece a equipe, e só devolve uma equipe quando o sinalizador é falso. Nada mais neste capítulo é tão importante quanto essa regra.

Este capítulo serve o adaptador em float32 que o capítulo 5 extraiu da gravação exatamente como estava. O capítulo 7 cria uma cópia int8 apenas nos pesos, banking77-lora-v1-int8, e mede essa cópia. Este capítulo não faz isso. Também não mede nada sobre velocidade. Essa comparação vem de uma gravação no capítulo 10, e nada neste capítulo a prevê.

Uma rota que devolve o encaminhamento

Última alteração na edição 2026.11.8

Uma rota é uma função que o framework web chama quando uma requisição chega a um caminho com um método. O framework aqui é o FastAPI, fixado em 0.163.2 em examples/requirements.txt. O roteador tem uma única rota, POST /route. Quem chama envia um objeto JSON com um campo, message, que contém o texto de uma mensagem da caixa de entrada. A rota responde com um objeto JSON de cinco campos: team, confidence, handed_off, adapter e version.

Cada campo tem uma única origem, e isso importa para o encaminhamento. O confidence é a probabilidade softmax da equipe escolhida pelo modelo, que é o sentido que o capítulo 5 lhe atribuiu. A flag handed_off é o resultado de handoff(confidence, threshold), que é verdadeiro quando a confiança está abaixo do limiar. A comparação está escrita como not confidence >= threshold, de modo que uma confiança que não seja um número, inclusive NaN, também é encaminhada. O limiar não é digitado na rota. A rota o lê do manifesto do adaptador, onde o capítulo 5 gravou o valor escolhido no split de desenvolvimento, de modo que a rota e o capítulo não podem discordar sobre o número. O team é None quando handed_off é verdadeiro, e é o rótulo da equipe caso contrário. Os campos adapter e version informam a quem chama qual modelo respondeu. O manifesto não tem campo para a versão do adaptador, então a versão é o sufixo do nome do adaptador: banking77-lora-v1 informa v1.

A rota chama o classificador uma vez por requisição. Uma única passagem direta fornece a equipe e a confiança juntas, e a flag é calculada a partir dessa mesma confiança. As duas não podem vir de chamadas diferentes e se afastar uma da outra. Quem abrir o módulo encontrará uma rota própria e um único caminho até uma equipe, a resposta que a rota monta depois que a flag é definida. O FastAPI acrescenta suas páginas de documentação, que não devolvem equipe. Recomendamos que um roteador mantenha esta forma: uma rota, uma chamada ao modelo, uma flag, e a equipe lida somente depois da flag. Uma segunda rota que pulasse a flag seria a maneira mais rápida de desfazer o trabalho do capítulo 5, e seria difícil de notar, porque ainda devolveria equipes corretas para as mensagens que não encaminha.

Cada mensagem de test_40, uma amostra fixa de 40 que o livro usa para verificações rápidas, vai para a rota, e o teste conta as flags e as equipes. Ele imprime contagens e nunca o texto de uma mensagem.

serve-route-testclient.py Python 3.12.15 · fastapi 0.163.2 · peft 0.21.3 · pydantic 2.14.4 · torch 2.15.0+cpu · torchao 0.18.0+cpu · transformers 5.23.0 Aprovado
"""Send the test_40 messages to the one POST /route through TestClient, in process, and print counts that tie thehand-off flag to the team. The prose's point rests on the "handed off, team is None" line and the "not handed off,team is the gold label" line; the last checks show the route's answer to a body with no message."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import torch  # noqa: E402torch.set_num_threads(2)from fastapi.testclient import TestClient  # noqa: E402import router_lib  # noqa: E402router_lib.setup_runtime()                  # seeds, deterministic algorithms and float32, so the counts repeatclient = TestClient(router_lib.make_app(router_lib.HERE / "data" / "recorded" / "lora-full"))  # checks the files, loads the model once, and reads the hand-off threshold from the adapter's manifesttest = router_lib.read_rows("test")         # each row is (message, gold label index)sample = router_lib.read_sample("test_40")  # row numbers of the committed samplereplies = [client.post("/route", json={"message": test[i][0]}) for i in sample]bodies = [r.json() for r in replies]gold = [test[i][1] for i in sample]         # gold label indexes; LABELS turns one into a team nameprint(f"responses: {len(replies)}")print(f"status codes: {sorted({r.status_code for r in replies})}")print(f"response keys: {sorted(bodies[0])}")print(f"handed off: {sum(b['handed_off'] for b in bodies)}/{len(bodies)}")print(f"team names outside the list: {sum(b['team'] is not None and b['team'] not in router_lib.LABELS for b in bodies)}")sure = [k for k, b in enumerate(bodies) if not b["handed_off"]]    # kept: the route returned a teamunsure = [k for k, b in enumerate(bodies) if b["handed_off"]]      # flagged: the route returned no teamprint(f"not handed off, team is the gold label: {sum(bodies[k]['team'] == router_lib.LABELS[gold[k]] for k in sure)}/{len(sure)}")print(f"handed off, team is None: {sum(bodies[k]['team'] is None for k in unsure)}/{len(unsure)}")print(f"adapter: {bodies[0]['adapter']}")print(f"version: {bodies[0]['version']}")bad = client.post("/route", json={})        # a body with no message field, which the route's body model requiresdetail_is_list = isinstance(bad.json()["detail"], list)assert detail_is_list, "a body with no message should get a 422 whose detail is a list"print(f"status on an empty body: {bad.status_code}")print(f"detail is a list: {'yes' if detail_is_list else 'no'}")
Saídapython serve-route-testclient.py
responses: 40
status codes: [200]
response keys: ['adapter', 'confidence', 'handed_off', 'team', 'version']
handed off: 8/40
team names outside the list: 0
not handed off, team is the gold label: 30/32
handed off, team is None: 8/8
adapter: banking77-lora-v1
version: v1
status on an empty body: 422
detail is a list: yes

A flag e a equipe concordam nesta amostra. A rota respondeu a todas as requisições, e a contagem de encaminhamentos é 8/40. Toda mensagem marcada voltou sem equipe: 8/8. Das mensagens que a rota manteve, 30/32 têm a equipe rotulada, o rótulo de referência contra o qual este livro calcula a pontuação. Essa contagem de mensagens mantidas é a medida que o capítulo 2 chama de acurácia nas mensagens não encaminhadas: as mensagens corretas entre as que a rota não marcou. Uma mensagem encaminhada não tem equipe para pontuar, então fica fora dessa contagem. A última contagem verifica o conjunto de rótulos: o número de nomes de equipe fora da lista é 0.

A saída mostra a forma da regra: uma mensagem marcada não tem equipe, e uma mensagem mantida tem uma. Isso vale para as 40 mensagens da amostra, o que é evidência, não uma prova sobre cada requisição. A prova está no código. O teste da rota verifica que o código faz o que a regra diz, em uma amostra que você pode executar novamente.

Regra prática: Calcule a flag na rota, a partir da mesma confiança da equipe, com handoff, e devolva uma equipe somente quando a flag for falsa. Não acrescente uma segunda rota, um campo ou uma opção que devolva uma equipe para uma mensagem que a flag marcou. Se quem chama precisar de uma equipe para toda mensagem, a resposta é uma pessoa para as mensagens que a flag marca, não uma equipe vinda da rota.

Carregue o modelo uma vez na inicialização

Última alteração na edição 2026.11.9

Uma rota que carregasse o modelo a cada requisição repetiria o mesmo trabalho a cada mensagem. A rota deste capítulo não faz isso, e o motivo está em onde o código fica. Antes de carregar qualquer coisa, a função make_app confere os arquivos do adaptador com o seu manifesto, e confere a revisão do modelo base com o pin que o manifesto registra. Ela levanta um erro e não constrói app algum se houver qualquer divergência. A verificação é a do capítulo 9, e este capítulo depende dela. Depois da verificação, make_app lê o manifesto, em seguida carrega o tokenizador e o modelo com load_classifier, e só então define a rota. A própria função da rota apenas chama classify e depois handoff. Assim, o modelo é carregado quando o app é construído, e cada requisição usa o modelo que já está na memória.

O teste da rota constrói o app uma única vez e envia todas as 40 mensagens para esse mesmo app, de modo que as 40 requisições compartilham um único carregamento. O carregamento faz parte da construção do app, não é um passo que quem chama precisa dar, e quem chama não consegue fazer a rota carregar uma segunda cópia apenas enviando uma requisição.

As threads são a outra configuração que pertence à inicialização. make_app recebe a contagem de threads como argumento threads, cujo padrão é dois, e chama torch.set_num_threads com essa contagem antes de carregar o modelo. Assim, todo processo que constrói o app define suas threads antes da primeira chamada ao modelo. A documentação do PyTorch diz que a chamada define a contagem de threads intra-op na CPU, e que "set_num_threads must be called before running eager, JIT or autograd code" para que a contagem seja mantida (documentação do torch 2.15.0+cpu).

A configuração set_num_threads cobre as threads usadas dentro de uma única operação, as threads intra-op que a documentação menciona. Duas threads é escolha do livro, não o melhor valor medido. Os exemplos do livro têm um orçamento de dois vCPUs, por isso o livro define duas threads para eles, e um leitor em outra máquina deve escolher uma contagem e medi-la. A escolha é identificada como sendo do livro, porque nenhum resultado deste capítulo compara uma contagem de threads com outra.

Regra prática: Construa o app uma vez por processo, com a contagem de threads que esse processo deve usar, e antes da primeira requisição. Com um orçamento de dois vCPUs, como o deste livro, mantenha o padrão de duas threads, e escolha outra contagem somente depois de medir a sua própria máquina com as suas próprias mensagens.

Saiba o que a rota não consegue pontuar

Última alteração na edição 2026.11.2

Dois tipos de requisição não podem ser pontuados, e a rota os trata de maneiras diferentes. O primeiro é uma requisição que não tem o campo de que a rota precisa. A rota declara seu corpo como um modelo com um único campo obrigatório, message. Um corpo sem esse campo recebe o status 422. O teste da rota termina enviando um corpo desse tipo, e o campo detail da resposta é uma lista, o que o teste verifica. Quem recebe um 422 não tem resposta para ler e não deve procurar uma equipe nesse corpo.

O segundo tipo de requisição é uma mensagem longa demais para ser lida por inteiro. O modelo lê uma mensagem como tokens, que são pedaços de texto, e uma mensagem longa tem mais deles. A função classify chama o tokenizador com truncamento ativado e max_length definido como 128. Uma mensagem com mais de 128 tokens é cortada em 128 antes de o modelo a ler. A rota não verifica o tamanho, e sua resposta não informa que houve corte. O mesmo 128 foi usado no treinamento: o script que registrou banking77-lora-v1, recordings/lora_full.py, treina com max_length definido como 128. Portanto, o corte na hora de servir é o mesmo corte com que o modelo foi treinado, e essa é a razão de a rota usá-lo.

Um corte menor, em 64 tokens, é uma escolha comum, e a contagem abaixo mostra o que ele afetaria na amostra de teste de 200 mensagens, a amostra com que o capítulo 5 comparou modelos. O exemplo mostra quantas das 200 mensagens são mais longas que cada corte. Apenas o tokenizador é carregado aqui, e nenhum modelo é executado.

truncation-count.py Python 3.12.15 · torch 2.15.0+cpu · transformers 5.23.0 Aprovado
"""Count the test_200 messages over 64 tokens and over the 128 that classify() cuts at, then show the cut on one longmessage. The prose's point rests on the 128-token line and the before and after lengths; only the tokenizer loads."""import osos.environ["HF_HUB_OFFLINE"] = "1"os.environ["TRANSFORMERS_OFFLINE"] = "1"import json  # noqa: E402import torch  # noqa: E402torch.set_num_threads(2)from transformers import AutoTokenizer  # noqa: E402import router_lib  # noqa: E402router_lib.setup_runtime()RECORDED = router_lib.HERE / "data" / "recorded" / "lora-full"repo = json.loads((RECORDED / "adapter" / "adapter_config.json").read_text())["base_model_name_or_path"]  # the adapter's base modeltokenizer = AutoTokenizer.from_pretrained(repo, revision=router_lib.pinned_revision(repo))  # the pinned revision the model usestest = router_lib.read_rows("test")         # each row is (message, gold label index)sample = router_lib.read_sample("test_200") # row numbers of the committed samplelengths = [len(tokenizer(test[i][0]).input_ids) for i in sample]  # full length in tokens, before any cutn = len(lengths)print(f"messages over 64 tokens: {sum(x > 64 for x in lengths)}/{n}")print(f"messages over 128 tokens where classify() cuts: {sum(x > 128 for x in lengths)}/{n}")# The cut itself: repeat the text of the first test_200 message until it is longer than 128 tokens,# then tokenize it with classify()'s settings (truncation on, max_length 128).long_text = test[sample[0]][0]while len(tokenizer(long_text).input_ids) <= 128:  # repeat the first message until it runs past the 128-token cut    long_text = long_text + " " + test[sample[0]][0]before = len(tokenizer(long_text).input_ids)after = len(tokenizer(long_text, truncation=True, max_length=128).input_ids)  # the settings classify() passesprint(f"repeated message tokens before the cut: {before}")print(f"repeated message tokens after the cut: {after}")print(f"truncation side: {tokenizer.truncation_side}")  # "right" cuts from the end of the text
Saídapython truncation-count.py
messages over 64 tokens: 1/200
messages over 128 tokens where classify() cuts: 0/200
repeated message tokens before the cut: 132
repeated message tokens after the cut: 128
truncation side: right

Nesta amostra, um corte em 64 tokens afetaria 1/200 mensagens, e o corte em 128 tokens, que classify aplica, afetaria 0/200. Assim como o teste da rota, isto é apenas uma amostra. Ela não diz com que frequência mensagens longas ocorrem em outra caixa de entrada, e essa taxa precisa ser contada nas mensagens do próprio leitor.

A segunda metade do exemplo mostra o que o corte faz com uma mensagem longa. Ele repete o texto da primeira mensagem de test_200 até que o texto tenha mais de 128 tokens e, então, tokeniza o resultado com as configurações que classify usa. A mensagem chega ao modelo com 128 tokens, em vez de 132. O lado de truncamento do tokenizador é right, portanto o corte descarta o fim do texto e mantém o início.

Um leitor cujas mensagens são mais longas do que esta amostra precisa contá-las antes de servir o modelo, pois a rota não fará essa contagem para ele. A rota não rejeita uma mensagem longa. Ela corta a mensagem, pontua o que sobrou e devolve uma equipe quando a flag é falsa, e nada na resposta mostra que houve corte. Por isso, a verificação cabe antes da rota, nas mãos de quem chama. Recomendamos tratar uma mensagem que a rota cortaria como uma mensagem para uma pessoa, fora da rota, e não como uma mensagem a adivinhar. Uma equipe adivinhada pareceria uma mensagem roteada e não carregaria flag, de modo que ninguém saberia que ela precisa de verificação. Uma mensagem tocada pelo corte é pontuada apenas no seu início, e quem chama não é informado. Isso é uma falha silenciosa, e o leitor deve decidir o que acontece com tais mensagens antes de a rota recebê-las. O resultado seguro, que este livro recomenda, é que uma mensagem longa vá para uma pessoa, fora da rota, com a contagem informada junto aos demais resultados.

Regra prática: Conte as mensagens mais longas que o corte antes de processar um conjunto de mensagens pela rota, com o tokenizador do modelo base do adaptador e o mesmo corte que a rota usa. A rota corta uma mensagem mais longa em 128 tokens e pontua apenas o que sobra; portanto, quando a contagem for maior que zero, envie essas mensagens a uma pessoa fora da rota e informe a contagem junto com a taxa de encaminhamento.

Teste a rota no mesmo processo

Última alteração na edição 2026.11.8

A regra da rota, uma equipe somente quando a flag for falsa, precisa ser verificada com respostas reais, e o cliente de teste do FastAPI permite que um teste faça isso sem iniciar um servidor. O tutorial de testes do FastAPI diz que o cliente de teste é usado como httpx, e que as chamadas a ele são chamadas comuns, sem await (tutorial de testes do FastAPI 0.163.2). Assim, um teste é um laço comum de Python, e cada chamada devolve uma resposta que ele pode ler.

O teste da rota usa esse cliente. Ele constrói a rota a partir da pasta gravada, envia a ela cada uma das 40 mensagens de test_40 e lê o JSON de cada resposta. Ele não inicia o uvicorn e não imprime o texto das mensagens. Todas as respostas voltaram com status 200, e o teste imprime as chaves da primeira resposta, que são os cinco campos listados em a primeira seção. As contagens que ele imprime são as que a regra da rota prevê: o número de mensagens encaminhadas, o número de mensagens sinalizadas sem equipe, o número de mensagens mantidas com a equipe correta (gold) e o número de nomes de equipe fora da lista. Ele também envia um corpo sem message, imprime o status dessa resposta e afirma que o campo detail é uma lista.

O teste não inicia um servidor, e isso é uma escolha. Um servidor iniciado dentro de um teste precisaria de uma porta livre, de uma espera pela inicialização e de um encerramento limpo, e cada uma dessas etapas pode falhar por motivos que nada têm a ver com a regra de encaminhamento. Um leitor que queira uma verificação contra um servidor em execução pode enviar as mesmas 40 mensagens a esse servidor e comparar as contagens dele com estas. A saída é a mesma em todas as execuções, porque setup_runtime, que o teste chama antes de construir a rota, fixa as sementes, exige algoritmos determinísticos e define o tipo padrão como float32. Um leitor que execute o teste de novo e obtenha contagens diferentes encontrou uma mudança no modelo, nos dados ou no ambiente, e deve parar e descobrir qual delas antes de confiar na rota.

A flag e a equipe são verificadas juntas, para cada resposta da amostra: uma resposta sinalizada não tem equipe, e uma resposta mantida tem uma. Um teste que verificasse apenas o código de status aprovaria uma rota que devolvesse uma equipe para toda mensagem, e deixaria passar a flag por completo. Por isso o teste imprime as duas contagens.

Regra prática: Teste a rota pelo cliente de teste, em uma amostra versionada, e imprima as contagens que ligam a flag à equipe: o número de mensagens encaminhadas, o número dessas sem equipe e o número de nomes de equipe fora da lista. Um teste que verifica apenas o código de status não mostra que a regra de encaminhamento vale. Cada afirmação que o teste faz deve ter uma linha impressa por trás, porque a linha é o que o livro pode citar e o leitor pode executar de novo. Uma afirmação sem linha é uma afirmação que o leitor precisa aceitar sem verificação.

O que dá errado em produção

Última alteração na edição 2026.11.2

Uma rota que passa no seu teste ainda pode falhar quando roda sob um servidor, e o teste não mostra essas falhas. O teste roda uma vez, sobre uma amostra versionada (commitada), com o código como ele está. A produção roda enquanto o serviço estiver no ar, sobre mensagens que ninguém amostrou, e muitas vezes em mais de um processo. Cada uma das falhas a seguir é uma forma de a amostra estar certa enquanto o serviço está errado. A primeira são as cópias do modelo. A página de deploy do uvicorn, o servidor sob o qual a rota deste capítulo deve rodar, diz que "Ao contrário do gunicorn, o uvicorn não usa pre-fork, mas usa spawn" (guia de deploy do uvicorn 0.54.0). Um worker criado por spawn é um novo processo Python. O módulo abaixo constrói a aplicação quando o uvicorn o importa, portanto cada worker que o importa carrega sua própria cópia do modelo. Lemos a citação sobre spawn como significando isso, e o capítulo não mede a memória que cada cópia custa. O leitor deve contar as cópias: o número de processos worker, multiplicado pelo tamanho do modelo na memória da sua própria máquina, antes de escolher quantos workers executar.

Executando a partir da pasta de exemplos, onde estão router_lib e data, o módulo que o uvicorn importa é uma linha de configuração e uma linha de aplicação:

# serve_route.py
import router_lib

app = router_lib.make_app("data/recorded/lora-full", threads=2)

O comando é uvicorn serve_route:app. O uvicorn recebe sua aplicação como "<module>:<attribute>", e sua página de configurações na mesma tag apresenta APP nesse formato.

A segunda é um conflito entre duas opções. A mesma página diz: "Os argumentos --reload e --workers são mutuamente exclusivos." Um leitor que desenvolve com recarregamento automático não consegue executar vários workers no mesmo comando. Um leitor que executa vários workers está rodando sem reload, então uma mudança no código exige reinício. Os dois fatos vêm da própria página do servidor, e ambos devem constar no runbook do leitor.

A terceira são as threads. Cada processo worker define a quantidade de threads que sua chamada make_app pede, então o total de threads cresce com o número de workers. Nas duas vCPUs que este livro prevê, duas threads por worker significam um worker. Recomendamos que o leitor conte o total de threads antes de adicionar um worker, e mantenha o total em no máximo o número de núcleos da máquina. Trata-se de uma heurística. Este capítulo não mede o que acontece quando o total ultrapassa o número de núcleos, e não afirma nenhum número para esse caso.

A quarta é a taxa de encaminhamento. A flag depende do limiar que o capítulo 5 escolheu na divisão de desenvolvimento, e das mensagens que a caixa de entrada envia. A rota devolve a flag em toda resposta, então a taxa de mensagens sinalizadas pode ser contada a partir da própria saída da rota. Se a taxa muda, a rota não consegue dizer por quê. Suas respostas não mostram se as mensagens da caixa de entrada mudaram, se o modelo mudou ou se o limiar foi editado. O capítulo 9 acompanha essa taxa, e acrescenta versões e um plano de contingência com pessoas.

A quinta são as mensagens longas, que a seção sobre o que a rota não consegue pontuar trata. O corte em 128 tokens não se anuncia, então a contagem acima deve ser refeita sobre as mensagens que a rota de fato recebe.

A sexta é a falta de registro. Uma rota que devolve a flag, mas registra apenas o código de status, não consegue mostrar, após uma mudança, como a taxa de encaminhamento se moveu. Recomendamos que cada resposta seja registrada com sua flag, seu adaptador e sua versão, para que a taxa possa ser contada tanto a partir dos logs quanto a partir do teste.

O que o capítulo definiu:

  • A rota devolve a flag em toda resposta, e uma equipe só entra quando a flag é falsa.
  • A rota serve banking77-lora-v1 em float32, com o limiar lido do seu manifesto.
  • Antes de carregar o modelo, make_app verifica os arquivos do adaptador e seu pin de base contra o manifesto, e não constrói nenhuma aplicação em caso de divergência (capítulo 9).
  • A rota corta cada mensagem em 128 tokens, o comprimento com que o modelo foi treinado.
  • Cada processo worker mantém um modelo e o constrói com duas threads, a escolha do livro para um orçamento de duas vCPUs.
  • A versão que a rota informa é o sufixo do nome do adaptador.

O encaminhamento se sustenta ou falha na rota, então a rota calcula a flag.

Regra prática: Execute um modelo por processo worker, construído com a quantidade de threads que você mediu para a sua máquina. Mantenha duas threads por worker, como este livro faz, até que a sua própria medição indique o contrário. Conte os processos worker antes de contar a memória do modelo na máquina, e mantenha --reload e --workers separados. Acompanhe a taxa de encaminhamento que a rota devolve, junto com os seus erros, desde o primeiro dia em que a rota servir mensagens.

Este capítulo, nesta edição

Edição 2026.11.9Exemplos aprovados em 20 de nov de 20262 de 2 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.9.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 8 de 10: Sirva o roteador em uma CPU, com a transferência para uma pessoa dentro da rota

  1. Uma rota que devolve o encaminhamento
  2. Carregue o modelo uma vez na inicialização
  3. Saiba o que a rota não consegue pontuar
  4. Teste a rota no mesmo processo
  5. O que dá errado em produção

Voltar ao topoTodos os capítulos