diff --git a/l10n/tmx/quarkus.tmx b/l10n/tmx/quarkus.tmx index 180f497987..8adaa9d4bd 100644 --- a/l10n/tmx/quarkus.tmx +++ b/l10n/tmx/quarkus.tmx @@ -6104,6 +6104,14 @@ The name of the feature gets displayed in the log during application bootstrap.< Uma _funcionalidade_ representa uma funcionalidade fornecida por uma extensão. O nome da funcionalidade é exibido no registro durante o bootstrap da aplicação. + + + A _service interface_ using the Mutiny API + + + Um _service interface_ usando a API Mutiny + + A `ClientHeadersFactory` can look as follows: @@ -6355,6 +6363,14 @@ Alternatively, if you want to apply the interceptor to any injected client then Um interceptor de cliente gRPC pode ser implementado por um bean CDI que também implementa a interface `io.grpc.ClientInterceptor` . Você pode anotar um cliente injetado com `@io.quarkus.grpc.RegisterClientInterceptor` para registrar o interceptor especificado para a instância específica do cliente. A anotação `@RegisterClientInterceptor` pode ser repetida. Como alternativa, se você deseja aplicar o interceptador a qualquer cliente injetado, anote o bean do interceptador com `@io.quarkus.grpc.GlobalInterceptor` . + + + A gRPC service implementation bean must be annotated with the `@GrpcService` annotation and should not declare any other CDI qualifier. All gRPC services have the `jakarta.inject.Singleton` scope. Additionally, the request context is always active during a service call. + + + Um bean de implementação de serviço gRPC deve ser anotado com a anotação '@GrpcService' e não deve declarar nenhum outro qualificador CDI. Todos os serviços gRPC têm o escopo 'jakarta.inject.Singleton'. Além disso, o contexto de solicitação está sempre ativo durante uma chamada de serviço. + + A haiku for you. @@ -6929,6 +6945,16 @@ You need to name your module in a unique way across all Jackson modules. Além disso, cada extensão que registra um contexto CDI personalizado através do `ContextRegistrationPhaseBuildItem` deve também produzir o `CustomScopeBuildItem` de modo a contribuir com o nome da anotação de escopo personalizado para o conjunto de anotações que definem o bean. + + + Additionally, if Quarkus SmallRye Health is added to the application, a readiness check for +the state of the gRPC services will be added to the MicroProfile Health endpoint response, that is `/q/health`. + + + Além disso, se o Quarkus SmallRye Health for adicionado ao aplicativo, uma verificação de prontidão para +o estado dos serviços gRPC será adicionado à resposta de ponto de extremidade do MicroProfile Health, ou seja, '/q/health'. + + Additionally, the bean resolver returned from `BeanDiscoveryFinishedBuildItem#getBeanResolver()` can be used to apply the type-safe resolution rules, e.g. to find out whether there is a bean that would satisfy certain combination of required type and qualifiers. @@ -7241,6 +7267,14 @@ Suppose we work on an imaginary "quarkus-parser" extension and we have a default Um IDE + + + An _implementation base_ class using the gRPC API + + + Uma classe _base de implementação_ que utiliza a API gRPC + + An `UnsatisfiedResolutionException` indicates a problem during xref:cdi.adoc#typesafe_resolution[typesafe resolution]. @@ -8475,6 +8509,14 @@ on Windows you should share your project's drive at Docker Desktop file share se Padrão Binder: Uma extensão pode optar por usar implementações de coleta completamente diferentes, dependendo do sistema de métricas. Um parâmetro da etapa de construção `Optional<MetricsCapabilityBuildItem> metricsCapability` pode ser usado para declarar ou inicializar métricas específicas da API com base na extensão de métricas ativa (por exemplo, "smallrye-metrics" ou "micrometer"). Este padrão pode ser combinado com o padrão Consumidor utilizando `MetricsFactory::metricsSystemSupported()` para testar a extensão de métrica ativa dentro do gravador. + + + Blocking Service Implementation + + + Implementação do serviço de bloqueio + + Blocking Stub @@ -8901,6 +8943,18 @@ to 300 seconds, use: `./mvnw verify -Dnative -Dquarkus.test.wait-time=300`.Por padrão, todos os arquivos localizados no diretório `src/main/resources/templates` e seus subdiretórios são registrados como modelos. Os modelos são validados durante o início da aplicação e monitorados para alterações no modo de desenvolvimento. + + + By default, all the methods from a gRPC service run on the event loop. +As a consequence, you must **not** block. +If your service logic must block, annotate the method with `io.smallrye.common.annotation.Blocking`: + + + Por padrão, todos os métodos de um serviço gRPC são executados no loop de eventos. +Como consequência, você deve **não** bloquear. +Se a lógica do serviço precisar bloquear, anote o método com 'io.smallrye.common.annotation.Blocking': + + By default, integration tests both *build* and *run* the native executable using the `prod` profile. @@ -8909,6 +8963,14 @@ to 300 seconds, use: `./mvnw verify -Dnative -Dquarkus.test.wait-time=300`.Por padrão, os testes de integração *build* e *run* são feitos usando o profile `prod`. + + + By default, quarkus-grpc starts a single gRPC server running on a single event loop. + + + Por padrão, o quarkus-grpc inicia um único servidor gRPC em execução em um único loop de eventos. + + By default, tests will run on port `8081` so as not to conflict with the running application. We automatically @@ -9364,6 +9426,14 @@ process. Consulte o link:https://grpc.github.io/grpc-java/javadoc/io/grpc/ClientInterceptor.html[JavaDoc do ClientInterceptor] para implementar corretamente o seu interceptor. + + + Check the https://grpc.github.io/grpc-java/javadoc/io/grpc/ServerInterceptor.html[ServerInterceptor JavaDoc] to properly implement your interceptor. + + + Verifique o https://grpc.github.io/grpc-java/javadoc/io/grpc/ServerInterceptor.html[ServerInterceptor JavaDoc] para implementar corretamente seu interceptador. + + Choose Your Lambda @@ -9504,6 +9574,16 @@ This is an important aspect to realize when integrating CDI components in Quarku Tempo limite da operação do cliente (em milissegundos). + + + Clients can specify the fully qualified service name to get the health status of a specific service +or skip specifying the service name to get the general status of the gRPC server. + + + Os clientes podem especificar o nome de serviço totalmente qualificado para obter o status de integridade de um serviço específico +ou ignore a especificação do nome do serviço para obter o status geral do servidor gRPC. + + Clock @@ -12028,6 +12108,14 @@ to create, delete, and update your lambdas. Linhas de Inicialização de Exemplo + + + Example of Configuration + + + Exemplo de configuração + + Example of Producing a ServiceStartBuildItem @@ -12817,6 +12905,14 @@ annotation indicates that the build step should not automatically be included so Por exemplo, o Quarkus otimiza o código do Hibernate porque sabe que só precisa de um conjunto de conexões e de um fornecedor de cache específicos + + + For example, if you use the following `proto` file snippet: + + + Por exemplo, se você usar o seguinte trecho de arquivo 'proto': + + For example, the `Jackson` extension uses code like below to search for annotations used in JSON deserialization, @@ -12897,6 +12993,16 @@ in another module, and Undertow will consume it and pass it into the recorder me Por exemplo, para fazer alterações arbitrárias em uma implantação de Servlet, o Undertow tem um `ServletExtensionBuildItem` , que é um `MultiBuildItem` que envolve uma instância de `ServletExtension` . Posso retornar um `ServletExtension` de um gravador em outro módulo, e o Undertow o consumirá e o passará para o método do gravador que inicia o Undertow. + + + For more details, check out the +https://github.com/grpc/grpc/blob/v1.28.1/doc/health-checking.md[gRPC documentation] + + + Para mais detalhes, confira o +https://github.com/grpc/grpc/blob/v1.28.1/doc/health-checking.md[documentação do gRPC] + + For more details, please see @@ -12963,6 +13069,14 @@ when using synchronous mode, due to issues in the GraalVM compilation (at presen Para a interface de Cliente REST `ExtensionsService` definida acima, um exemplo de utilização de `@ClientExceptionMapper` seria: + + + For the implemented services, Quarkus gRPC exposes health information in the following format: + + + Para os serviços implementados, o Quarkus gRPC expõe informações de integridade no seguinte formato: + + For the last 25 years, Java has performed for organizations across the world but you've never seen anything like this. We'll cover all the classics like "Start Me Up" and "Living' on a VM" and some new jams like "Stairway to Native" and "Sweet JPA of Mine" and more. @@ -13172,6 +13286,14 @@ If you have GraalVM installed and it matches this version, you can start the nat Gerar o bytecode da implementação `jakarta.enterprise.context.spi.Contextual#create(CreationalContext<T>)`. + + + Generated Code + + + Código Gerado + + Generating the documentation @@ -13586,6 +13708,14 @@ Content-Type: application/json O HTTP/2 está desabilitado por padrão no Cliente REST. Se pretende habilitar, pode definir: + + + Handling Streams + + + Manipulação de fluxos + + Handling restarts @@ -13666,6 +13796,14 @@ As opções disponíveis são as seguintes: + Veja mais detalhadamente como o SmallRye Stork pode ser configurado e usado. + + + Having it, you can run the dev mode with: `mvn quarkus:dev -Pdevelopment`. + + + Tendo isso, você pode executar o modo dev com: 'mvn quarkus:dev -Pdevelopment'. + + Having such property groups brings more structure to your configuration. @@ -14915,6 +15053,14 @@ reinicie o aplicativo com: Se você utilizar a Basic ou form-based, você precisará adicionar uma instãncia `IdentityProvider` para converter um username e um password em uma instância `SecurityIdentity`. + + + If you use Gradle, you can simply add a dependency for the `quarkusDev` task: + + + Se você usar o Gradle, você pode simplesmente adicionar uma dependência para a tarefa 'quarkusDev': + + If you use a `CompletionStage`, you would need to call the service's method to retry. @@ -15007,6 +15153,14 @@ code to a native executable. Just make sure to rebuild your project with the `- Se você quiser utilizar a API REST do AWS Gateway, gere o seu projeto com este script: + + + If you wish to scale your server, you can set the number of server instances by setting `quarkus.grpc.server.instances`. + + + Se você deseja dimensionar seu servidor, você pode definir o número de instâncias do servidor definindo 'quarkus.grpc.server.instances'. + + If you're running a remote Docker daemon, you need to replace `quarkus.native.container-build=true` with `quarkus.native.remote-container-build=true`. @@ -15149,6 +15303,30 @@ annotated method on a worker thread instead of the I/O thread (event-loop).Implementando serviços GraphQL + + + Implementing a Service with the Mutiny API + + + Implementando um serviço com a API Mutiny + + + + + Implementing a Service with the default gRPC API + + + Implementando um serviço com a API gRPC padrão + + + + + Implementing a gRPC Service + + + Implementando um serviço gRPC + + Implementing a gRPC service @@ -15157,6 +15335,16 @@ annotated method on a worker thread instead of the I/O thread (event-loop).Implementação de um serviço gRPC + + + Implementing a gRPC service requires the gRPC classes to be generated. +Place your `proto` files in `src/main/proto` and run `mvn compile`. + + + A implementação de um serviço gRPC requer que as classes gRPC sejam geradas. +Coloque seus arquivos 'proto' em 'src/main/proto' e execute 'mvn compile'. + + Implementing a service @@ -15458,6 +15646,16 @@ For example, the container validates every injection point in the application an No pacote `org.acme.scheduler`, crie a classe `CounterBean`, com o seguinte conteúdo: + + + In the dev mode, you can try out your gRPC services in the Quarkus Dev UI. +Just go to http://localhost:8080/q/dev-v1 and click on _Services_ under the gRPC tile. + + + No modo de desenvolvimento, você pode experimentar seus serviços gRPC na interface do usuário de desenvolvimento do Quarkus. +Basta ir até http://localhost:8080/q/dev-v1 e clicar em _Services_ sob o bloco gRPC. + + In the example above, `GeneratedClassBuildItem` would only be produced if `ExecutorClassBuildItem` is consumed by @@ -18395,6 +18593,16 @@ items will not be invoked. Observe que um método `@BuildStep` só será chamado se produzir algo que outro consumidor ou o resultado final exija. Se não houver um consumidor para um determinado item, ele não será produzido. O que é necessário dependerá do destino final que está sendo produzido. Por exemplo, ao executar no modo de desenvolvedor, a saída final não solicitará itens de construção específicos do GraalVM, como `ReflectiveClassBuildItem`, portanto, os métodos que produzem apenas esses itens não serão chamados. + + + Note that all paths in the configuration may either specify a resource on the classpath +(typically from `src/main/resources` or its subfolder) or an external file. + + + Observe que todos os caminhos na configuração podem especificar um recurso no classpath +(normalmente de 'src/main/resources' ou sua subpasta) ou um arquivo externo. + + Note that all three models can be used in a single application. @@ -19492,6 +19700,18 @@ MIME type. You can override these defaults with the `@PartType` annotation.Thread de plataforma + + + Please note that in the case of using a client to test an exposed service that does not use TLS, +there is no need to provide any configuration. E.g. to test the `HelloService` +defined above, one could create the following test: + + + Observe que, no caso de usar um cliente para testar um serviço exposto que não usa TLS, +Não há necessidade de fornecer nenhuma configuração. Por exemplo, para testar o 'HelloService' +definido acima, pode-se criar o seguinte teste: + + Please note that since the invocation is now non-blocking, the `idAsync` method will be invoked on the event loop, @@ -19515,6 +19735,14 @@ but be aware that you won't get security updates that way and it's unsupported.< Observe que o comando acima aponta para um indicador flutuante. É altamente recomendável usar o indicador flutuante para que a imagem do construtor permaneça atualizada e segura. Se for absolutamente necessário, você pode codificar para um indicador específico (veja https://quay.io/repository/quarkus/ubi-quarkus-mandrel-builder-image?tab=tags[aqui] os indicadores disponíveis), mas esteja ciente de que não receberá atualizações de segurança dessa forma e não há suporte para isso. + + + Please note that your application needs to expose the "normal" HTTP port for the Dev UI to be accessible. If your application does not expose any HTTP endpoints, you can create a dedicated profile with a dependency on `quarkus-vertx-http`: + + + Observe que seu aplicativo precisa expor a porta HTTP "normal" para que a interface do usuário de desenvolvimento seja acessível. Se seu aplicativo não expor nenhum ponto de extremidade HTTP, você poderá criar um perfil dedicado com uma dependência em 'quarkus-vertx-http': + + Please refer to https://github.com/quarkusio/quarkus/blob/{quarkus-version}/devtools/maven/src/main/java/io/quarkus/maven/CreateExtensionMojo.java[CreateExtensionMojo JavaDoc] for all the available options of the mojo. @@ -20147,6 +20375,14 @@ Each content type resolves a different user need, fulfills a different purpose, A documentação do Quarkus está estruturada em quatro tipos de conteúdo distintos: conceitos, instruções, tutoriais e referências. A composição e a estrutura dos documentos do Quarkus seguem a estrutura de documentação sistemática da Diátaxis para a criação de documentação técnica. Cada tipo de conteúdo atende a uma necessidade diferente do usuário, cumpre uma finalidade diferente e exige uma abordagem diferente para sua criação. + + + Quarkus exposes both the reflection service `v1` and `v1alpha`. + + + O Quarkus expõe o reflection service `v1` e `v1alpha`. + + Quarkus extensions add a new developer focused behavior to the core offering, and consist of two distinct parts, buildtime augmentation and runtime container. The augmentation part is responsible for all metadata processing, such as reading annotations, XML descriptors etc. The output of this augmentation phase is recorded bytecode which is responsible for directly instantiating the relevant runtime services. @@ -20173,6 +20409,16 @@ Each content type resolves a different user need, fulfills a different purpose, O Quarkus se concentra na maneira mais simples e útil de usar um determinado recurso, cortando-o para sua essência mais útil. Isso inclui uma análise inicial sobre como usar melhor um recurso e orientá-lo no que achamos ser a melhor maneira de fazer as coisas. + + + Quarkus gRPC Server implements the https://github.com/grpc/grpc/blob/master/doc/server-reflection.md[reflection service]. +This service allows tools like https://github.com/fullstorydev/grpcurl[grpcurl] or https://github.com/gusaul/grpcox[grpcox] to interact with your services. + + + O Quarkus gRPC Server implementa o https://github.com/grpc/grpc/blob/master/doc/server-reflection.md[reflection service]. +Este serviço permite que ferramentas como https://github.com/fullstorydev/grpcurl[grpcurl] ou https://github.com/gusaul/grpcox[grpcox] interajam com seus serviços. + + Quarkus gRPC is based on https://vertx.io/docs/vertx-grpc/java/[Vert.x gRPC]. @@ -20181,6 +20427,14 @@ Each content type resolves a different user need, fulfills a different purpose, O Quarkus gRPC é baseado no link:https://vertx.io/docs/vertx-grpc/java/[Vert.x gRPC]. + + + Quarkus generates a few implementation classes for services declared in the `proto` file: + + + O Quarkus gera algumas classes de implementação para serviços declarados no arquivo 'proto': + + Quarkus generates a lot of classes during the build phase and in many cases also transforms existing classes. @@ -21592,6 +21846,14 @@ The `event` parameter takes any JSON file, in this case the sample `payload.json Salve esse arquivo em `src/main/docker/Dockerfile.multistage`, uma vez que não está incluído no startup rápido. + + + Scaling + + + Dimensionamento + + Scan the `quarkusio` catalog for aliases prefixed with `quarkus-`. @@ -21872,6 +22134,22 @@ The `event` parameter takes any JSON file, in this case the sample `payload.json Serialização + + + Server Configuration + + + Configuração do Servidor + + + + + Server Interceptors + + + Interceptores de servidor + + Server configuration @@ -22972,6 +23250,14 @@ Quarkus application for each test class. Testes com a SAM CLI + + + Testing your services + + + Testando seus serviços + + Thanks to the <a href="https://quarkus.io/version/main/guides/mutiny-primer">Mutiny Reactive API</a> , you can compose asynchronous operations and complete the result when everything is done without blocking the I/O threads. This greatly improves resource consumption and elasticity. Most Quarkus APIs are available in both imperative and reactive. As example, you can use the reactive version of the REST Client: @@ -24187,6 +24473,16 @@ as a `Map`, which is convenient if parameters are not known in advance. A maneira mais fácil de especificar um parâmetro de consulta é anotar um parâmetro de método do cliente com `@QueryParam` ou `@RestQuery` . O `@RestQuery` é equivalente ao `@QueryParam` , mas com nome opcional. Além disso, ele também pode ser usado para passar parâmetros de consulta como `Map` , o que é conveniente se os parâmetros não forem conhecidos antecipadamente. + + + The easiest way to test a gRPC service is to use a gRPC client as described +in xref:grpc-service-consumption.adoc[Consuming a gRPC Service]. + + + A maneira mais fácil de testar um serviço gRPC é usar um cliente gRPC conforme descrito +em xref:grpc-service-consumption.adoc[Consumindo um serviço gRPC]. + + The effective catalog is the combination of both the `user` and `project` catalogs with the latter being able to override entries of the former (e.g. use a different version or location for a plugin). @@ -24943,6 +25239,16 @@ The project generation has provided a `Dockerfile.native-micro` in the `src/main O gravador deve ser executado na fase `ExecutionTime.RUNTIME_INIT`. + + + The reflection service is enabled by default in _dev_ mode. +In test or production mode, you need to enable it explicitly by setting `quarkus.grpc.server.enable-reflection-service` to `true`. + + + O reflection service é habilitado por padrão no modo _dev_. +No modo de teste ou produção, você precisa habilitá-lo explicitamente definindo 'quarkus.grpc.server.enable-reflection-service' como 'true'. + + The resulting bean class is something like `public class @Singleton MyBean { }`. @@ -25023,6 +25329,14 @@ Tipo: _string_ A URL do serviço Pulsar + + + The service implementation bean can also extend the Mutiny implementation base, where the class name is structured as follows: `Mutiny${NAME_OF_THE_SERVICE}Grpc.${NAME_OF_THE_SERVICE}ImplBase`. + + + O bean de implementação de serviço também pode estender a base de implementação do Mutiny , onde o nome da classe é estruturado da seguinte maneira: 'Mutiny${NAME_OF_THE_SERVICE}Grpc.${NAME_OF_THE_SERVICE}ImplBase'. + + The service name is derived from the injection point - the field name is used. The `quarkus.grpc.clients.hello.host` property must be set. @@ -25323,6 +25637,14 @@ Tipo: _long_ Em seguida, execute: + + + Then the service interface is `hello.Greeter` and the implementation base is the abstract static nested class: `hello.GreeterGrpc.GreeterImplBase`. + + + Em seguida, a interface de serviço é 'Olá. Greeter' e a base de implementação é a classe aninhada estática abstrata: 'hello. GreeterGrpc.GreeterImplBase'. + + Then the service interface name is: `hello.Greeter`, the Mutiny stub name is: `hello.MutinyGreeterGrpc.MutinyGreeterStub` and the blocking stub name is: `hello.GreeterGrpc.GreeterBlockingStub`. @@ -27533,6 +27855,16 @@ after each run, and can be reused. To add any of the installable plugins, use `quarkus plugin add <name or location>`: + + + To apply an interceptor to all exposed services, annotate it with `@io.quarkus.grpc.GlobalInterceptor`. +To apply an interceptor to a single service, register it on the service with `@io.quarkus.grpc.RegisterInterceptor`: + + + Para aplicar um interceptador a todos os serviços expostos, anote-o com '@io.quarkus.grpc.GlobalInterceptor'. +Para aplicar um interceptador a um único serviço, registre-o no serviço com '@io.quarkus.grpc.RegisterInterceptor': + + To better understand the contrast, we need to explain the difference between the reactive and imperative execution models. @@ -27646,6 +27978,14 @@ It's essential to comprehend that _Reactive_ is not just a different execution m Para desativar as métricas do cliente gRPC quando se utiliza `quarkus-micrometer`, adicione a seguinte propriedade à configuração da aplicação: + + + To disable the gRPC server metrics when `quarkus-micrometer` is used, add the following property to the application configuration: + + + Para desabilitar as métricas do servidor gRPC quando 'quarkus-micrometer' for usado, adicione a seguinte propriedade à configuração do aplicativo: + + To do this, first create a directory `src/main/zip.native/` with your build. Next create a shell script file called `bootstrap` @@ -27655,6 +27995,14 @@ within `src/main/zip.native/`, like below. An example is created automatically i Para fazer isso, primeiro crie um diretório `src/main/zip.native/` com sua compilação. Em seguida, crie um arquivo de script de shell chamado `bootstrap` dentro de `src/main/zip.native/`, como abaixo. Um exemplo é criado automaticamente em sua pasta de compilação (target ou build), chamado `bootstrap-example.sh` + + + To enable TLS, use the following configuration. + + + Para habilitar o TLS, use a configuração a seguir. + + To enable TLS, use the following configuration. @@ -27786,6 +28134,32 @@ Let's see it in action by adding a `getByIdAsync` method in our `ExtensionsServi Para obter todo o poder da natureza reativa do cliente, você pode usar a variante não blocante da extensão Cliente REST Reativo, que vem com suporte para `CompletionStage` e `Uni` . Vamos ver isso em ação adicionando um método `getByIdAsync` em nossa interface REST `ExtensionsService` . O código deve ter a seguinte aparência: + + + To implement a gRPC service using the Mutiny API, create a class that implements the service interface. +Then, implement the methods defined in the service interface. +If you don't want to implement a service method just throw an `java.lang.UnsupportedOperationException` from the method body (the exception will be automatically converted to the appropriate gRPC exception). +Finally, implement the service and add the `@GrpcService` annotation: + + + Para implementar um serviço gRPC usando a API Mutiny , crie uma classe que implemente a interface de serviço. +Em seguida, implemente os métodos definidos na interface de serviço. +Se você não quiser implementar um método de serviço, basta lançar um 'java.lang.UnsupportedOperationException' do corpo do método (a exceção será convertida automaticamente para a exceção gRPC apropriada). +Finalmente, implemente o serviço e adicione a anotação '@GrpcService': + + + + + To implement a gRPC service using the default gRPC API, create a class that extends the default implementation base. +Then, override the methods defined in the service interface. +Finally, implement the service and add the `@GrpcService` annotation: + + + Para implementar um serviço gRPC usando a API gRPC padrão, crie uma classe que estenda a base de implementação padrão. +Em seguida, substitua os métodos definidos na interface de serviço. +Finalmente, implemente o serviço e adicione a anotação '@GrpcService': + + To include only a specific config group: @@ -28023,6 +28397,14 @@ used as a marker for Quarkus generation tool, but it is also used by the `javado Para utilizar a API `MetricFactory` agnóstica em termos de extensão, o seu processador pode definir um `BuildStep` que produz um `MetricsFactoryConsumerBuildItem` que usa um Gravador `RUNTIME_INIT` ou `STATIC_INIT` para definir um consumidor `MetricsFactory`. + + + To use virtual threads in your gRPC service implementation, check the dedicated xref:./grpc-virtual-threads.adoc[guide]. + + + Para usar threads virtuais na implementação do serviço gRPC, verifique o xref:./grpc-virtual-threads.adoc[guia] dedicado. + + To verify your setup, that you have the AWS CLI installed, executed aws configure for the AWS access keys, @@ -28158,6 +28540,14 @@ O valor padrão e mínimo é 1 minuto. Dicas de Resolução de Problemas / Depuração + + + Trying out your services manually + + + Experimentando seus serviços manualmente + + Tutorials @@ -28666,6 +29056,14 @@ it should be invoked as soon as possible. The invocation of the scheduled method Utilize clientes compatíveis com threads virtuais + + + Use virtual threads + + + Usar threads virtuais + + Use worker thread (limit concurrency) @@ -28946,6 +29344,14 @@ it should be invoked as soon as possible. The invocation of the scheduled method Utilizar as opções de monitoração + + + Using Mutiny, you can implement these as follows: + + + Usando o Mutiny, você pode implementá-los da seguinte maneira: + + Using OAuth2 RBAC @@ -30228,6 +30634,18 @@ At build time, Quarkus tries to deduce the types from the application code, but Quando a propriedade de destino do xDS é utilizada, o resolvedor de nomes, host e porta não são utilizados. + + + When you disable `quarkus.grpc.server.use-separate-server`, you are then using the new Vert.x gRPC server implementation +which uses the existing HTTP server. Which means that the server port is now `8080` (or the port configured with `quarkus.http.port`). +Also, most of the other configuration properties are no longer applied, since it's the HTTP server that should already be properly configured. + + + Quando você desabilita 'quarkus.grpc.server.use-separate-server', você está usando a nova implementação do servidor gRPC Vert.x +que usa o servidor HTTP existente. O que significa que a porta do servidor agora é '8080' (ou a porta configurada com 'quarkus.http.port'). +Além disso, a maioria das outras propriedades de configuração não são mais aplicadas, pois é o servidor HTTP que já deve estar configurado corretamente. + + When you enable `quarkus.grpc.clients."client-name".use-quarkus-grpc-client`, you are then using the new Vert.x gRPC channel implementation, so not all configuration properties can still be applied. And currently there is no Stork support yet. @@ -30244,6 +30662,14 @@ At build time, Quarkus tries to deduce the types from the application code, but Quando você habilita `quarkus.grpc.clients."client-name".xds.enabled`, é o xDS que deve tratar da maior parte da configuração acima. + + + When you enable `quarkus.grpc.server.xds.enabled`, it's the xDS that should handle most of the configuration above. + + + Quando você habilita 'quarkus.grpc.server.xds.enabled', é o xDS que deve lidar com a maior parte da configuração acima. + + When you have multiple client interceptors, you can order them by implementing the `jakarta.enterprise.inject.spi.Prioritized` interface: @@ -30252,6 +30678,16 @@ At build time, Quarkus tries to deduce the types from the application code, but Quando tem vários interceptadores de clientes, pode ordená-los implementando a interface `jakarta.enterprise.inject.spi.Prioritized`: + + + When you have multiple server interceptors, you can order them by implementing the `jakarta.enterprise.inject.spi.Prioritized` interface. Please note that all the global interceptors are invoked before the service-specific +interceptors. + + + Quando você tem vários interceptadores de servidor, você pode encomendá-los implementando a interface 'jakarta.enterprise.inject.spi.Priorizd'. Observe que todos os interceptores globais são invocados antes do serviço específico +Interceptadores. + + When your repository contains multiple extensions, you need to create a separate file for each individual extension, not just one file for the entire repository. @@ -31157,6 +31593,14 @@ describes how to set it up in detail. Você pode ir para https://code.quarkus.io/[code.quarkus.io] para ver se uma determinada extensão é _stable_ (padrão) ou _preview_. + + + You can implement a gRPC server interceptor by creating an `@ApplicationScoped` bean implementing `io.grpc.ServerInterceptor`: + + + Você pode implementar um interceptor de servidor gRPC criando um bean '@ApplicationScoped' implementando 'io.grpc.ServerInterceptor': + + You can make your extension support the xref:dev-ui-v2.adoc[Quarkus Dev UI] for a greater developer experience. @@ -31451,6 +31895,14 @@ The name of the deployment module can be configured in the plugin by setting the Você precisa incluir o `io.quarkus:quarkus-extension-maven-plugin` e configurar o `maven-compiler-plugin` para detectar o processador de anotações `quarkus-extension-processor` para recolher e gerar os xref:extension-metadata.html[metadados de extensão Quarkus] necessários para os artefatos de extensão. Se estiver utilizando o pom principal do Quarkus, este herdará automaticamente a configuração correta. + + + You'll need to implement the _service interface_ or extend the _base class_ with your service implementation bean as described in the following sections. + + + Você precisará implementar o _service interface_ ou estender o _base class_ com seu bean de implementação de serviço, conforme descrito nas seções a seguir. + + Your `proto` file must not contain `option java_generic_services = true;`. https://developers.google.com/protocol-buffers/docs/reference/java-generated?hl=en#service[Generic services are deprecated] and are not compatible with Quarkus code generation plugins. @@ -32036,6 +32488,14 @@ ordered. This is not enforced but failure to adhere to this rule can result in r Exemplo de `GeneratedBeanBuildItem` + + + `Greeter` is the service name. + + + `Greeter` é o nome do serviço. + + `GrpcClientUtils` work with all flavors of clients. @@ -32380,6 +32840,22 @@ artifact produced by the Maven build - it is *not* the runnable jar; produzido pela compilação do Maven - *não* é o jar executável; + + + `hello.Greeter` is the generated service interface. + + + `hello.Greeter` é a interface de serviço gerada. + + + + + `hello` is the java package for the generated classes. + + + `hello` é o pacote java para as classes geradas. + + `hello` is the name used in the `@GrpcClient` annotation. @@ -34496,6 +34972,22 @@ de documentos (um guia de instruções, por exemplo). Cabeçalhos gRPC + + + gRPC Server metrics + + + Métricas do gRPC Server + + + + + gRPC allows receiving and returning streams: + + + gRPC permite receber e retornar fluxos: + + gRPC allows sending and receiving streams: @@ -34530,6 +35022,32 @@ You can inject: A geração do gRPC fornece vários stubs, oferecendo diferentes maneiras de consumir um serviço gRPC. Você pode injetar: + + + gRPC server interceptors let you perform logic, such as authentication, before your service is invoked. + + + Os interceptadores de servidor gRPC permitem que você execute lógica, como autenticação, antes que seu serviço seja chamado. + + + + + gRPC server metrics are automatically enabled when the application also uses the xref:telemetry-micrometer.adoc[`quarkus-micrometer`] extension. +Micrometer collects the metrics of all the gRPC services implemented by the application. + + + As métricas do servidor gRPC são ativadas automaticamente quando o aplicativo também usa a extensão xref:telemetry-micrometer.adoc['quarkus-micrometer']. +O Micrometer coleta as métricas de todos os serviços gRPC implementados pelo aplicativo. + + + + + gRPC service implementations exposed as CDI beans are automatically registered and served by quarkus-grpc. + + + As implementações de serviço gRPC expostas como beans CDI são automaticamente registradas e servidas pelo quarkus-grpc. + + gcp-functions-http.adoc @@ -38225,6 +38743,22 @@ pois as dependências são copiadas para subdiretórios em `quarkus-app/lib/` .< o arquivo de configuração da aplicação + + + the class name is `${JAVA_PACKAGE}.${NAME_OF_THE_SERVICE}` + + + o nome da classe é '${JAVA_PACKAGE}.${NAME_OF_THE_SERVICE}' + + + + + the class name is structured as follows: `${JAVA_PACKAGE}.${NAME_OF_THE_SERVICE}Grpc.${NAME_OF_THE_SERVICE}ImplBase` + + + o nome da classe está estruturado da seguinte forma: '${JAVA_PACKAGE}.${NAME_OF_THE_SERVICE}Grpc.${NAME_OF_THE_SERVICE}ImplBase' + + the client stub is injected with the `@RestClient` annotation instead of the usual CDI `@Inject`