From 465d5dcd7a81bd5fcd50b357958aeda2da0beb96 Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Thu, 11 Mar 2021 22:54:11 -0300 Subject: [PATCH 1/6] Starting translation to pt --- .../containers/container-lifecycle-hooks.md | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 content/pt/docs/concepts/containers/container-lifecycle-hooks.md diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md new file mode 100644 index 0000000000..fab8e4cd86 --- /dev/null +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -0,0 +1,128 @@ +--- +title: Ciclos de Vida do Contêiner +content_type: concept +weight: 30 +--- + + + +Essa página descreve como os contêineres gerenciados pelo _kubelet_ podem usar a estrutura de _hook_ de ciclo de vida do contêiner para executar código acionado por eventos durante seu ciclo de vida de gerenciamento. + + + + +## Visão Geral + +Análogo a muitas estruturas de linguagem de programação que tem _hooks_ de ciclo de vida de componentes, como angular, +o Kubernetes fornece aos contêineres _hooks_ de ciclo de vida. +Os _hooks_ permitem que os contêineres estejam cientes dos eventos em seu ciclo de vida de gerenciamento +e executem código implementado em um manipulador quando o _hook_ de ciclo de vida correspondente é executado. + +## Hooks do contêiner + +Existem dois _hooks_ que são expostos para os contêiners: + +`PostStart` + +This hook is executed immediately after a container is created. +However, there is no guarantee that the hook will execute before the container ENTRYPOINT. +No parameters are passed to the handler. + +`PreStop` + +This hook is called immediately before a container is terminated due to an API request or management +event such as a liveness/startup probe failure, preemption, resource contention and others. A call +to the `PreStop` hook fails if the container is already in a terminated or completed state and the +hook must complete before the TERM signal to stop the container can be sent. The Pod's termination +grace period countdown begins before the `PreStop` hook is executed, so regardless of the outcome of +the handler, the container will eventually terminate within the Pod's termination grace period. No +parameters are passed to the handler. + +A more detailed description of the termination behavior can be found in +[Termination of Pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination). + +### Hook handler implementations + +Containers can access a hook by implementing and registering a handler for that hook. +There are two types of hook handlers that can be implemented for Containers: + +* Exec - Executes a specific command, such as `pre-stop.sh`, inside the cgroups and namespaces of the Container. +Resources consumed by the command are counted against the Container. +* HTTP - Executes an HTTP request against a specific endpoint on the Container. + +### Hook handler execution + +When a Container lifecycle management hook is called, +the Kubernetes management system execute the handler according to the hook action, +`httpGet` and `tcpSocket` are executed by the kubelet process, and `exec` is executed in the container. + +Hook handler calls are synchronous within the context of the Pod containing the Container. +This means that for a `PostStart` hook, +the Container ENTRYPOINT and hook fire asynchronously. +However, if the hook takes too long to run or hangs, +the Container cannot reach a `running` state. + +`PreStop` hooks are not executed asynchronously from the signal to stop the Container; the hook must +complete its execution before the TERM signal can be sent. If a `PreStop` hook hangs during +execution, the Pod's phase will be `Terminating` and remain there until the Pod is killed after its +`terminationGracePeriodSeconds` expires. This grace period applies to the total time it takes for +both the `PreStop` hook to execute and for the Container to stop normally. If, for example, +`terminationGracePeriodSeconds` is 60, and the hook takes 55 seconds to complete, and the Container +takes 10 seconds to stop normally after receiving the signal, then the Container will be killed +before it can stop normally, since `terminationGracePeriodSeconds` is less than the total time +(55+10) it takes for these two things to happen. + +If either a `PostStart` or `PreStop` hook fails, +it kills the Container. + +Users should make their hook handlers as lightweight as possible. +There are cases, however, when long running commands make sense, +such as when saving state prior to stopping a Container. + +### Hook delivery guarantees + +Hook delivery is intended to be *at least once*, +which means that a hook may be called multiple times for any given event, +such as for `PostStart` or `PreStop`. +It is up to the hook implementation to handle this correctly. + +Generally, only single deliveries are made. +If, for example, an HTTP hook receiver is down and is unable to take traffic, +there is no attempt to resend. +In some rare cases, however, double delivery may occur. +For instance, if a kubelet restarts in the middle of sending a hook, +the hook might be resent after the kubelet comes back up. + +### Debugging Hook handlers + +The logs for a Hook handler are not exposed in Pod events. +If a handler fails for some reason, it broadcasts an event. +For `PostStart`, this is the `FailedPostStartHook` event, +and for `PreStop`, this is the `FailedPreStopHook` event. +You can see these events by running `kubectl describe pod `. +Here is some example output of events from running this command: + +``` +Events: + FirstSeen LastSeen Count From SubObjectPath Type Reason Message + --------- -------- ----- ---- ------------- -------- ------ ------- + 1m 1m 1 {default-scheduler } Normal Scheduled Successfully assigned test-1730497541-cq1d2 to gke-test-cluster-default-pool-a07e5d30-siqd + 1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulling pulling image "test:1.0" + 1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Created Created container with docker id 5c6a256a2567; Security:[seccomp=unconfined] + 1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Pulled Successfully pulled image "test:1.0" + 1m 1m 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Started Started container with docker id 5c6a256a2567 + 38s 38s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 5c6a256a2567: PostStart handler: Error executing in Docker Container: 1 + 37s 37s 1 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Normal Killing Killing container with docker id 8df9fdfd7054: PostStart handler: Error executing in Docker Container: 1 + 38s 37s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} Warning FailedSync Error syncing pod, skipping: failed to "StartContainer" for "main" with RunContainerError: "PostStart handler: Error executing in Docker Container: 1" + 1m 22s 2 {kubelet gke-test-cluster-default-pool-a07e5d30-siqd} spec.containers{main} Warning FailedPostStartHook +``` + + + +## {{% heading "whatsnext" %}} + + +* Learn more about the [Container environment](/docs/concepts/containers/container-environment/). +* Get hands-on experience + [attaching handlers to Container lifecycle events](/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/). + From 3a71a0064f535b6d447ae0cba8bef48825f0f3d6 Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Sun, 14 Mar 2021 09:55:39 -0300 Subject: [PATCH 2/6] Add partial translation --- .../containers/container-lifecycle-hooks.md | 48 ++++++++++--------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md index fab8e4cd86..e7c925866a 100644 --- a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -28,12 +28,13 @@ This hook is executed immediately after a container is created. However, there is no guarantee that the hook will execute before the container ENTRYPOINT. No parameters are passed to the handler. +Este _hook_ é executado imediatamente após um contêiner ser criado. +Entretanto, não há garantia que o _hook_ será executado antes do ENTRYPOINT do contêiner. +Nenhum parâmetro é passado para o manipulador. + `PreStop` -This hook is called immediately before a container is terminated due to an API request or management -event such as a liveness/startup probe failure, preemption, resource contention and others. A call -to the `PreStop` hook fails if the container is already in a terminated or completed state and the -hook must complete before the TERM signal to stop the container can be sent. The Pod's termination +The Pod's termination grace period countdown begins before the `PreStop` hook is executed, so regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period. No parameters are passed to the handler. @@ -41,37 +42,38 @@ parameters are passed to the handler. A more detailed description of the termination behavior can be found in [Termination of Pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination). -### Hook handler implementations +Esse _hook_ é chamado imediatamente antes de um contêiner ser encerrado devido a uma solicitação de API ou um gerenciamento de evento como liveness/startup probe failure, preemption, resource contention e outros. +Uma chamada ao _hook_ `PreStop` falha se o contêiner já está em um estado finalizado ou concluído e o _hook_ deve ser concluído antes que o sinal TERM seja enviado para parar o contêiner. -Containers can access a hook by implementing and registering a handler for that hook. -There are two types of hook handlers that can be implemented for Containers: -* Exec - Executes a specific command, such as `pre-stop.sh`, inside the cgroups and namespaces of the Container. -Resources consumed by the command are counted against the Container. -* HTTP - Executes an HTTP request against a specific endpoint on the Container. +### Implementações de manipulador de hook -### Hook handler execution +Os contêineres podem acessar um _hook_ implementando e registrando um manipulador para esse _hook_. +Existem dois tipos de manipuladores de _hooks_ que podem ser implementados para contêineres: -When a Container lifecycle management hook is called, -the Kubernetes management system execute the handler according to the hook action, -`httpGet` and `tcpSocket` are executed by the kubelet process, and `exec` is executed in the container. +* Exec - Executa um comando específico, como `pre-stop.sh`, dentro do cgroups e Namespaces do contêiner. +* HTTP - Executa uma requisição HTTP em um endpoint específico do contêiner. -Hook handler calls are synchronous within the context of the Pod containing the Container. -This means that for a `PostStart` hook, -the Container ENTRYPOINT and hook fire asynchronously. -However, if the hook takes too long to run or hangs, -the Container cannot reach a `running` state. +### Execução do manipulador de hook -`PreStop` hooks are not executed asynchronously from the signal to stop the Container; the hook must -complete its execution before the TERM signal can be sent. If a `PreStop` hook hangs during -execution, the Pod's phase will be `Terminating` and remain there until the Pod is killed after its -`terminationGracePeriodSeconds` expires. This grace period applies to the total time it takes for + +Quando um _hook_ de gerenciamento de ciclo de vida do contêiner é chamado, o sistema de gerenciamento do Kubernetes executa o manipulador de acordo com a ação do _hook_, `httpGet` e `tcpSocker` são executados pelo processo kubelet e `exec` é executado pelo contêiner. + +As chamadas do manipulador do _hook_ são síncronas no contexto do Pod que contém o contêiner. +Isso significa que para um _hook_ `PostStart`, o ENTRYPOINT do contêiner e o _hook_ disparam de forma assíncrona. +No entanto, se o _hook_ demorar muito para ser executado ou travar, o contêiner não consegue atingir o estado `running`. + +This grace period applies to the total time it takes for both the `PreStop` hook to execute and for the Container to stop normally. If, for example, `terminationGracePeriodSeconds` is 60, and the hook takes 55 seconds to complete, and the Container takes 10 seconds to stop normally after receiving the signal, then the Container will be killed before it can stop normally, since `terminationGracePeriodSeconds` is less than the total time (55+10) it takes for these two things to happen. +Os _hooks_ `PreStop` não são executados de forma assíncrona a partir do sinal para parar o conêiner, o _hook_ precisa finalizar a sua execução antes que o sinal TERM possa ser enviado. +Se um _hook_ `PreStop` travar durante a execução, a fase do Pod será `Terminating` e permanecerá até que o Pod seja morto após seu `terminationGracePeriodSeconds` expirar. + + If either a `PostStart` or `PreStop` hook fails, it kills the Container. From 686327077692f31bb7555c8d602f5221dec2afbb Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Wed, 17 Mar 2021 23:29:01 -0300 Subject: [PATCH 3/6] Add the content of content/pt/docs/concepts/containers/container-lifecycle-hooks.md --- .../containers/container-lifecycle-hooks.md | 79 ++++++++----------- 1 file changed, 31 insertions(+), 48 deletions(-) diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md index e7c925866a..d0419bbc4e 100644 --- a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -24,27 +24,16 @@ Existem dois _hooks_ que são expostos para os contêiners: `PostStart` -This hook is executed immediately after a container is created. -However, there is no guarantee that the hook will execute before the container ENTRYPOINT. -No parameters are passed to the handler. - Este _hook_ é executado imediatamente após um contêiner ser criado. Entretanto, não há garantia que o _hook_ será executado antes do ENTRYPOINT do contêiner. Nenhum parâmetro é passado para o manipulador. `PreStop` -The Pod's termination -grace period countdown begins before the `PreStop` hook is executed, so regardless of the outcome of -the handler, the container will eventually terminate within the Pod's termination grace period. No -parameters are passed to the handler. - -A more detailed description of the termination behavior can be found in -[Termination of Pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination). - Esse _hook_ é chamado imediatamente antes de um contêiner ser encerrado devido a uma solicitação de API ou um gerenciamento de evento como liveness/startup probe failure, preemption, resource contention e outros. -Uma chamada ao _hook_ `PreStop` falha se o contêiner já está em um estado finalizado ou concluído e o _hook_ deve ser concluído antes que o sinal TERM seja enviado para parar o contêiner. +Uma chamada ao _hook_ `PreStop` falha se o contêiner já está em um estado finalizado ou concluído e o _hook_ deve ser concluído antes que o sinal TERM seja enviado para parar o contêiner. A contagem regressiva do período de tolerância de término do Pod começa antes que o _hook_ `PreStop` seja executado, portanto, independentemente do resultado do manipulador, o contêiner será encerrado dentro do período de tolerância de encerramento do Pod. Nenhum parâmetro é passado para o manispulador. +Uma descrição mais detalhada do comportamento de término pode ser encontrada em [Término de Pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination). ### Implementações de manipulador de hook @@ -63,47 +52,41 @@ As chamadas do manipulador do _hook_ são síncronas no contexto do Pod que cont Isso significa que para um _hook_ `PostStart`, o ENTRYPOINT do contêiner e o _hook_ disparam de forma assíncrona. No entanto, se o _hook_ demorar muito para ser executado ou travar, o contêiner não consegue atingir o estado `running`. -This grace period applies to the total time it takes for -both the `PreStop` hook to execute and for the Container to stop normally. If, for example, -`terminationGracePeriodSeconds` is 60, and the hook takes 55 seconds to complete, and the Container -takes 10 seconds to stop normally after receiving the signal, then the Container will be killed -before it can stop normally, since `terminationGracePeriodSeconds` is less than the total time -(55+10) it takes for these two things to happen. Os _hooks_ `PreStop` não são executados de forma assíncrona a partir do sinal para parar o conêiner, o _hook_ precisa finalizar a sua execução antes que o sinal TERM possa ser enviado. -Se um _hook_ `PreStop` travar durante a execução, a fase do Pod será `Terminating` e permanecerá até que o Pod seja morto após seu `terminationGracePeriodSeconds` expirar. +Se um _hook_ `PreStop` travar durante a execução, a fase do Pod será `Terminating` e permanecerá até que o Pod seja morto após seu `terminationGracePeriodSeconds` expirar. Esse período de tolerância se aplica ao tempo total necessário +para o _hook_ `PreStop`executar e para o contêiner parar normalmente. +Se por exemplo, o `terminationGracePeriodSeconds` é 60, e o _hook_ leva 55 segundos para ser concluído, e o contêiner leva 10 segundos para parar normalmente após receber o sinal, então o contêiner será morto antes que possa parar +normalmente, uma vez que o `terminationGracePeriodSeconds` é menor que o tempo total (55 + 10) que é necessário para que essas duas coisas aconteçam. +Se um _hook_ `PostStart` ou `PreStop` falhar, ele mata o contêiner. -If either a `PostStart` or `PreStop` hook fails, -it kills the Container. +Os usuários devem tornar seus _hooks_ o mais leve possíveis. +Há casos, no entanto, em que comandos de longa duração fazem sentido, como ao salvar o estado +antes de parar um contêiner. -Users should make their hook handlers as lightweight as possible. -There are cases, however, when long running commands make sense, -such as when saving state prior to stopping a Container. +### Garantias de entrega de _hooks_ -### Hook delivery guarantees +A entrega do _hook_ é destinada a acontecer *pelo menos uma vez*, +o que quer dizer que um _hook_ pode ser chamado várias vezes para qualquer evento, +como para `PostStart` ou `PreStop`. +Depende da implementação do _hook_ lidar com isso corretamente. -Hook delivery is intended to be *at least once*, -which means that a hook may be called multiple times for any given event, -such as for `PostStart` or `PreStop`. -It is up to the hook implementation to handle this correctly. +Geralmente, apenas entregas únicas são feitas. +Se, por exemplo, um receptor de _hook_ HTTP estiver inativo e não puder receber tráfego, +não há tentativa de reenviar. +Em alguns casos raros, no entanto, pode ocorrer uma entrega dupla. +Por exemplo, se um kubelet reiniciar no meio do envio de um _hook_, o _hook_ pode ser +reenviado depois que o kubelet voltar a funcionar. -Generally, only single deliveries are made. -If, for example, an HTTP hook receiver is down and is unable to take traffic, -there is no attempt to resend. -In some rare cases, however, double delivery may occur. -For instance, if a kubelet restarts in the middle of sending a hook, -the hook might be resent after the kubelet comes back up. - -### Debugging Hook handlers - -The logs for a Hook handler are not exposed in Pod events. -If a handler fails for some reason, it broadcasts an event. -For `PostStart`, this is the `FailedPostStartHook` event, -and for `PreStop`, this is the `FailedPreStopHook` event. -You can see these events by running `kubectl describe pod `. -Here is some example output of events from running this command: +### Depurando manipuladores de _hooks_ +Os logs para um manipulador de _hook_ não expostos em eventos de Pod. +Se um manipulador falhar por algum motivo, ele transmitirá um evento. +Para `PostStart` é o evento `FailedPostStartHook` e para `PreStop` é o evento +`failedPreStopHook`. +Você pode ver esses eventos executando `kubectl describe pod `. +Aqui está um exemplo de saída de eventos da execução deste comando: ``` Events: FirstSeen LastSeen Count From SubObjectPath Type Reason Message @@ -124,7 +107,7 @@ Events: ## {{% heading "whatsnext" %}} -* Learn more about the [Container environment](/docs/concepts/containers/container-environment/). -* Get hands-on experience - [attaching handlers to Container lifecycle events](/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/). +* Saiba mais sobre o [Ambiente de contêiner](/docs/concepts/containers/container-environment/). +* Obtenha experiência prática + [anexando manipuladores a eventos de ciclo de vida do contêiner](/docs/tasks/configure-pod-container/attach-handler-lifecycle-event/). From dd892357088d165fae23d4ce0c899470da155188 Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Wed, 17 Mar 2021 23:32:40 -0300 Subject: [PATCH 4/6] Add extra space at line 90 --- content/pt/docs/concepts/containers/container-lifecycle-hooks.md | 1 + 1 file changed, 1 insertion(+) diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md index d0419bbc4e..5c54c374d6 100644 --- a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -87,6 +87,7 @@ Para `PostStart` é o evento `FailedPostStartHook` e para `PreStop` é o evento `failedPreStopHook`. Você pode ver esses eventos executando `kubectl describe pod `. Aqui está um exemplo de saída de eventos da execução deste comando: + ``` Events: FirstSeen LastSeen Count From SubObjectPath Type Reason Message From 90e2984666e1d08512cbbaca9cbea140d22ab22b Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Wed, 17 Mar 2021 23:49:02 -0300 Subject: [PATCH 5/6] Fix title --- .../pt/docs/concepts/containers/container-lifecycle-hooks.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md index 5c54c374d6..ec7a7fd55c 100644 --- a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -1,5 +1,5 @@ --- -title: Ciclos de Vida do Contêiner +title: Hooks de Ciclo de Vida do Contêiner content_type: concept weight: 30 --- From b12cbb5a0d20c22b070d3202fcff430b55e30b96 Mon Sep 17 00:00:00 2001 From: edsoncelio Date: Fri, 19 Mar 2021 16:26:36 -0300 Subject: [PATCH 6/6] =?UTF-8?q?Fix=20the=20typos=20suggested=20by=20code?= =?UTF-8?q?=20review=20*=20manispulador=20->=20manipulador=20*=20dentro=20?= =?UTF-8?q?do=20cgroup=20e=20namespace=20do=20container=20->=20dentro=20do?= =?UTF-8?q?s=20cgroups=20e=20namespaces=20*=20tcpSocker=20->=20tcpSocket?= =?UTF-8?q?=20*=20con=C3=AAiner->=20cont=C3=AAiner=20*=20Os=20logs=20para?= =?UTF-8?q?=20um=20manipulador=20de=20=5Fhook=5F=20n=C3=A3o=20expostos=20e?= =?UTF-8?q?m=20eventos=20de=20Pod=20->=20Os=20logs=20para=20um=20manipulad?= =?UTF-8?q?or=20de=20=5Fhook=5F=20n=C3=A3o=20s=C3=A3o=20expostos=20em=20ev?= =?UTF-8?q?entos=20de=20Pod.=20*=20failedPreStopHook=20->=20FailedPreStopH?= =?UTF-8?q?ook?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../concepts/containers/container-lifecycle-hooks.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md index ec7a7fd55c..984f248256 100644 --- a/content/pt/docs/concepts/containers/container-lifecycle-hooks.md +++ b/content/pt/docs/concepts/containers/container-lifecycle-hooks.md @@ -31,7 +31,7 @@ Nenhum parâmetro é passado para o manipulador. `PreStop` Esse _hook_ é chamado imediatamente antes de um contêiner ser encerrado devido a uma solicitação de API ou um gerenciamento de evento como liveness/startup probe failure, preemption, resource contention e outros. -Uma chamada ao _hook_ `PreStop` falha se o contêiner já está em um estado finalizado ou concluído e o _hook_ deve ser concluído antes que o sinal TERM seja enviado para parar o contêiner. A contagem regressiva do período de tolerância de término do Pod começa antes que o _hook_ `PreStop` seja executado, portanto, independentemente do resultado do manipulador, o contêiner será encerrado dentro do período de tolerância de encerramento do Pod. Nenhum parâmetro é passado para o manispulador. +Uma chamada ao _hook_ `PreStop` falha se o contêiner já está em um estado finalizado ou concluído e o _hook_ deve ser concluído antes que o sinal TERM seja enviado para parar o contêiner. A contagem regressiva do período de tolerância de término do Pod começa antes que o _hook_ `PreStop` seja executado, portanto, independentemente do resultado do manipulador, o contêiner será encerrado dentro do período de tolerância de encerramento do Pod. Nenhum parâmetro é passado para o manipulador. Uma descrição mais detalhada do comportamento de término pode ser encontrada em [Término de Pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination). @@ -40,20 +40,20 @@ Uma descrição mais detalhada do comportamento de término pode ser encontrada Os contêineres podem acessar um _hook_ implementando e registrando um manipulador para esse _hook_. Existem dois tipos de manipuladores de _hooks_ que podem ser implementados para contêineres: -* Exec - Executa um comando específico, como `pre-stop.sh`, dentro do cgroups e Namespaces do contêiner. +* Exec - Executa um comando específico, como `pre-stop.sh`, dentro dos cgroups e Namespaces do contêiner. * HTTP - Executa uma requisição HTTP em um endpoint específico do contêiner. ### Execução do manipulador de hook -Quando um _hook_ de gerenciamento de ciclo de vida do contêiner é chamado, o sistema de gerenciamento do Kubernetes executa o manipulador de acordo com a ação do _hook_, `httpGet` e `tcpSocker` são executados pelo processo kubelet e `exec` é executado pelo contêiner. +Quando um _hook_ de gerenciamento de ciclo de vida do contêiner é chamado, o sistema de gerenciamento do Kubernetes executa o manipulador de acordo com a ação do _hook_, `httpGet` e `tcpSocket` são executados pelo processo kubelet e `exec` é executado pelo contêiner. As chamadas do manipulador do _hook_ são síncronas no contexto do Pod que contém o contêiner. Isso significa que para um _hook_ `PostStart`, o ENTRYPOINT do contêiner e o _hook_ disparam de forma assíncrona. No entanto, se o _hook_ demorar muito para ser executado ou travar, o contêiner não consegue atingir o estado `running`. -Os _hooks_ `PreStop` não são executados de forma assíncrona a partir do sinal para parar o conêiner, o _hook_ precisa finalizar a sua execução antes que o sinal TERM possa ser enviado. +Os _hooks_ `PreStop` não são executados de forma assíncrona a partir do sinal para parar o contêiner, o _hook_ precisa finalizar a sua execução antes que o sinal TERM possa ser enviado. Se um _hook_ `PreStop` travar durante a execução, a fase do Pod será `Terminating` e permanecerá até que o Pod seja morto após seu `terminationGracePeriodSeconds` expirar. Esse período de tolerância se aplica ao tempo total necessário para o _hook_ `PreStop`executar e para o contêiner parar normalmente. Se por exemplo, o `terminationGracePeriodSeconds` é 60, e o _hook_ leva 55 segundos para ser concluído, e o contêiner leva 10 segundos para parar normalmente após receber o sinal, então o contêiner será morto antes que possa parar @@ -81,10 +81,10 @@ reenviado depois que o kubelet voltar a funcionar. ### Depurando manipuladores de _hooks_ -Os logs para um manipulador de _hook_ não expostos em eventos de Pod. +Os logs para um manipulador de _hook_ não são expostos em eventos de Pod. Se um manipulador falhar por algum motivo, ele transmitirá um evento. Para `PostStart` é o evento `FailedPostStartHook` e para `PreStop` é o evento -`failedPreStopHook`. +`FailedPreStopHook`. Você pode ver esses eventos executando `kubectl describe pod `. Aqui está um exemplo de saída de eventos da execução deste comando: