From 8c187458d4a37811cf93c97c843315e655115746 Mon Sep 17 00:00:00 2001
From: Ali Dowair <adowair@umich.edu>
Date: Tue, 28 Nov 2023 04:56:54 -0800
Subject: [PATCH 1/2] Localize home/supported-doc-versions.md in Arabic

This commit will add a file content/ar/home/support-doc-versions.md
containing an Arabic translation of the `content/en` counterpart.
---
 content/ar/docs/home/supported-doc-versions.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 content/ar/docs/home/supported-doc-versions.md

diff --git a/content/ar/docs/home/supported-doc-versions.md b/content/ar/docs/home/supported-doc-versions.md
new file mode 100644
index 0000000000000..7c8ee65226d20
--- /dev/null
+++ b/content/ar/docs/home/supported-doc-versions.md
@@ -0,0 +1,14 @@
+---
+title: إصدارات التوثيق المتوفرة
+content_type: custom
+layout: supported-versions
+card:
+  name: about
+  weight: 10
+  title: إصدارات التوثيق المتوفرة
+---
+
+يوثقُ هذا الموقع الإصدار الحالي والإصدارات الأربع السابقة من كوبرنيتيس.
+
+لا يرتبط وجود توثيقٍ لإصدارٍ معينٍ بالدعم الرسمي لهذا الإصدار.
+تعَرَّف على الإصدارات المدعومة، ومدةِ دعمها، على صفحة [مُدَّة الدعم](/releases/patch-releases/#support-period).
\ No newline at end of file

From e74d66cfe1f2512bc6932879ca5b0fbeaf3e5a41 Mon Sep 17 00:00:00 2001
From: "xin.li" <xin.li@daocloud.io>
Date: Mon, 8 Jan 2024 22:14:09 +0800
Subject: [PATCH 2/2] [zh-cn] sync coarse-parallel-processing-work-queue.md

Signed-off-by: xin.li <xin.li@daocloud.io>
---
 .../coarse-parallel-processing-work-queue.md  | 270 ++++++++++--------
 1 file changed, 155 insertions(+), 115 deletions(-)

diff --git a/content/zh-cn/docs/tasks/job/coarse-parallel-processing-work-queue.md b/content/zh-cn/docs/tasks/job/coarse-parallel-processing-work-queue.md
index 4a48febbd3421..80a193750d5cd 100644
--- a/content/zh-cn/docs/tasks/job/coarse-parallel-processing-work-queue.md
+++ b/content/zh-cn/docs/tasks/job/coarse-parallel-processing-work-queue.md
@@ -1,13 +1,11 @@
 ---
 title: 使用工作队列进行粗粒度并行处理
-min-kubernetes-server-version: v1.8
 content_type: task
 weight: 20
 ---
 
 <!--
 title: Coarse Parallel Processing Using a Work Queue
-min-kubernetes-server-version: v1.8
 content_type: task
 weight: 20
 -->
@@ -15,7 +13,7 @@ weight: 20
 <!-- overview -->
 
 <!--
-In this example, we will run a Kubernetes Job with multiple parallel
+In this example, you will run a Kubernetes Job with multiple parallel
 worker processes.
 
 In this example, as each pod is created, it picks up one unit of work
@@ -23,14 +21,14 @@ from a task queue, completes it, deletes it from the queue, and exits.
 
 Here is an overview of the steps in this example:
 
-1. **Start a message queue service.**  In this example, we use RabbitMQ, but you could use another
+1. **Start a message queue service.**  In this example, you use RabbitMQ, but you could use another
    one.  In practice you would set up a message queue service once and reuse it for many jobs.
 1. **Create a queue, and fill it with messages.**  Each message represents one task to be done.  In
    this example, a message is an integer that we will do a lengthy computation on.
 1. **Start a Job that works on tasks from the queue**.  The Job starts several pods.  Each pod takes
    one task from the message queue, processes it, and exits.
 -->
-本例中，我们会运行包含多个并行工作进程的 Kubernetes Job。
+本例中，你将会运行包含多个并行工作进程的 Kubernetes Job。
 
 本例中，每个 Pod 一旦被创建，会立即从任务队列中取走一个工作单元并完成它，然后将工作单元从队列中删除后再退出。
 
@@ -51,15 +49,24 @@ Here is an overview of the steps in this example:
 
 
 <!--
-Be familiar with the basic,
+You should already be familiar with the basic,
 non-parallel, use of [Job](/docs/concepts/workloads/controllers/job/).
 -->
 
-要熟悉 Job 基本用法（非并行的），请参考
+你应当熟悉 Job 的基本用法（非并行的），请参考
 [Job](/zh-cn/docs/concepts/workloads/controllers/job/)。
 
 {{< include "task-tutorial-prereqs.md" >}} 
 
+<!--
+You will need a container image registry where you can upload images to run in your cluster.
+
+This task example also assumes that you have Docker installed locally.
+-->
+你需要一个容器镜像仓库，用来向其中上传镜像以在集群中运行。
+
+此任务示例还假设你已在本地安装了 Docker。
+
 <!-- steps -->
 
 <!--
@@ -80,27 +87,25 @@ Start RabbitMQ as follows:
 
 按下面的方法启动 RabbitMQ：
 
+<!--
+# make a Service for the StatefulSet to use
+-->
 ```shell
-kubectl create -f https://raw.githubusercontent.com/kubernetes/kubernetes/release-1.3/examples/celery-rabbitmq/rabbitmq-service.yaml
+# 为 StatefulSet 创建一个 Service 来使用
+kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq-service.yaml
 ```
 ```
 service "rabbitmq-service" created
 ```
 
 ```shell
-kubectl create -f https://raw.githubusercontent.com/kubernetes/kubernetes/release-1.3/examples/celery-rabbitmq/rabbitmq-controller.yaml
+kubectl create -f https://kubernetes.io/examples/application/job/rabbitmq-statefulset.yaml
 ```
 
 ```
-replicationcontroller "rabbitmq-controller" created
+statefulset "rabbitmq" created
 ```
 
-<!--
-We will only use the rabbitmq part from the [celery-rabbitmq example](https://github.com/kubernetes/kubernetes/tree/release-1.3/examples/celery-rabbitmq).
--->
-我们仅用到
-[celery-rabbitmq 示例](https://github.com/kubernetes/kubernetes/tree/release-1.3/examples/celery-rabbitmq)中描述的部分功能。
-
 <!--
 ## Testing the message queue service
 
@@ -119,7 +124,7 @@ First create a temporary interactive Pod.
 
 ```shell
 # 创建一个临时的可交互的 Pod
-kubectl run -i --tty temp --image ubuntu:18.04
+kubectl run -i --tty temp --image ubuntu:22.04
 ```
 ```
 Waiting for pod default/temp-loe07 to be running, status is Pending, pod ready: false
@@ -129,114 +134,134 @@ Waiting for pod default/temp-loe07 to be running, status is Pending, pod ready:
 <!--
 Note that your pod name and command prompt will be different.
 
-Next install the `amqp-tools` so we can work with message queues.
+Next install the `amqp-tools` so you can work with message queues.
+The next commands show what you need to run inside the interactive shell in that Pod:
 -->
 请注意你的 Pod 名称和命令提示符将会不同。
 
-接下来安装 `amqp-tools`，这样我们就能用消息队列了。
+接下来安装 `amqp-tools`，这样你就能用消息队列了。
+下面是在该 Pod 的交互式 shell 中需要运行的命令：
 
 ```shell
-# 安装一些工具
-root@temp-loe07:/# apt-get update
-.... [ lots of output ] ....
-root@temp-loe07:/# apt-get install -y curl ca-certificates amqp-tools python dnsutils
-.... [ lots of output ] ....
+apt-get update && apt-get install -y curl ca-certificates amqp-tools python dnsutils
 ```
 
 <!--
-Later, we will make a docker image that includes these packages.
+Later, you will make a container image that includes these packages.
 
-Next, we will check that we can discover the rabbitmq service:
+Next, you will check that you can discover the Service for RabbitMQ:
 -->
-后续，我们将制作一个包含这些包的 Docker 镜像。
+后续，你将制作一个包含这些包的容器镜像。
 
-接着，我们将要验证可以发现 RabbitMQ 服务：
+接着，你将要验证可以发现 RabbitMQ 服务：
 
 <!--
+# Run these commands inside the Pod
 # Note the rabbitmq-service has a DNS name, provided by Kubernetes:
 -->
 ```
+# 在 Pod 内运行这些命令
 # 请注意 rabbitmq-service 拥有一个由 Kubernetes 提供的 DNS 名称：
 
-root@temp-loe07:/# nslookup rabbitmq-service
+nslookup rabbitmq-service
+```
+```
 Server:        10.0.0.10
 Address:    10.0.0.10#53
 
 Name:    rabbitmq-service.default.svc.cluster.local
 Address: 10.0.147.152
-
-# 你的 IP 地址会不同
 ```
+<!--
+(the IP addresses will vary)
+-->
+（IP 地址会有所不同）
 
 <!--
-If Kube-DNS is not set up correctly, the previous step may not work for you.
-You can also find the service IP in an env var:
+If the kube-dns addon is not set up correctly, the previous step may not work for you.
+You can also find the IP address for that Service in an environment variable:
 -->
-如果 Kube-DNS 没有正确安装，上一步可能会出错。
-你也可以在环境变量中找到服务 IP。
+如果 kube-dns 插件没有正确安装，上一步可能会出错。
+你也可以在环境变量中找到该服务的 IP 地址。
 
 <!--
-# Your address will vary.
+# run this check inside the Pod
 -->
+```shell
+# 在 Pod 内运行此检查
+env | grep RABBITMQ_SERVICE | grep HOST
+```
 ```
-# env | grep RABBIT | grep HOST
 RABBITMQ_SERVICE_SERVICE_HOST=10.0.147.152
-
-# 你的 IP 地址会有所不同
 ```
+<!--
+(the IP address will vary)
+-->
+（IP 地址会有所不同）
 
 <!--
-Next we will verify we can create a queue, and publish and consume messages.
+Next you will verify that you can create a queue, and publish and consume messages.
 -->
-接着我们将要确认可以创建队列，并能发布消息和消费消息。
+接下来，你将验证是否可以创建队列以及发布和使用消息。
 
 <!--
+# Run these commands inside the Pod
 # In the next line, rabbitmq-service is the hostname where the rabbitmq-service
 # can be reached.  5672 is the standard port for rabbitmq.
 
 # If you could not resolve "rabbitmq-service" in the previous step,
 # then use this command instead:
-# root@temp-loe07:/# BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672
 # Now create a queue:
 -->
 
 ```shell
+# 在 Pod 内运行这些命令
 # 下一行，rabbitmq-service 是访问 rabbitmq-service 的主机名。5672是 rabbitmq 的标准端口。
 
-root@temp-loe07:/# export BROKER_URL=amqp://guest:guest@rabbitmq-service:5672
+export BROKER_URL=amqp://guest:guest@rabbitmq-service:5672
 
 # 如果上一步中你不能解析 "rabbitmq-service"，可以用下面的命令替换：
-# root@temp-loe07:/# BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672
+BROKER_URL=amqp://guest:guest@$RABBITMQ_SERVICE_SERVICE_HOST:5672
 
 # 现在创建队列：
 
-root@temp-loe07:/# /usr/bin/amqp-declare-queue --url=$BROKER_URL -q foo -d foo
+/usr/bin/amqp-declare-queue --url=$BROKER_URL -q foo -d foo
+```
+```
+foo
+```
 
-# 向它推送一条消息：
+<!--
+Publish one message to the queue:
+# And get it back.
+-->
+向队列推送一条消息：
 
-root@temp-loe07:/# /usr/bin/amqp-publish --url=$BROKER_URL -r foo -p -b Hello
+```shell
+/usr/bin/amqp-publish --url=$BROKER_URL -r foo -p -b Hello
 
 # 然后取回它：
 
-root@temp-loe07:/# /usr/bin/amqp-consume --url=$BROKER_URL -q foo -c 1 cat && echo
+/usr/bin/amqp-consume --url=$BROKER_URL -q foo -c 1 cat && echo
+```
+```
 Hello
-root@temp-loe07:/#
 ```
 
 <!--
-In the last command, the `amqp-consume` tool takes one message (`-c 1`)
+In the last command, the `amqp-consume` tool took one message (`-c 1`)
 from the queue, and passes that message to the standard input of an arbitrary command.
-In this case, the program `cat` prints out the characters read from standard input, and the echo adds a carriage
-return so the example is readable.
+In this case, the program `cat` prints out the characters read from standard input, and
+the echo adds a carriage return so the example is readable.
 -->
 
 最后一个命令中，`amqp-consume` 工具从队列中取走了一个消息，并把该消息传递给了随机命令的标准输出。
 在这种情况下，`cat` 会打印它从标准输入中读取的字符，echo 会添加回车符以便示例可读。
 
 <!--
-## Filling the Queue with tasks
+## Fill the Queue with tasks
 
-Now let's fill the queue with some "tasks".  In our example, our tasks are strings to be
+Now, fill the queue with some simulated tasks.  In this example, the tasks are strings to be
 printed.
 
 In a practice, the content of the messages might be:
@@ -249,7 +274,7 @@ In a practice, the content of the messages might be:
 -->
 ## 为队列增加任务  {#filling-the-queue-with-tasks}
 
-现在让我们给队列增加一些任务。在我们的示例中，任务是多个待打印的字符串。
+现在用一些模拟任务填充队列。在此示例中，任务是多个待打印的字符串。
 
 实践中，消息的内容可以是：
 
@@ -260,23 +285,37 @@ In a practice, the content of the messages might be:
 - 待渲染的场景的帧序列号
 
 <!--
-In practice, if there is large data that is needed in a read-only mode by all pods
-of the Job, you will typically put that in a shared file system like NFS and mount
-that readonly on all the pods, or the program in the pod will natively read data from
-a cluster file system like HDFS.
+If there is large data that is needed in a read-only mode by all pods
+of the Job, you typically put that in a shared file system like NFS and mount
+that readonly on all the pods, or write the program in the pod so that it can natively read
+data from a cluster file system (for example: HDFS).
 
-For our example, we will create the queue and fill it using the amqp command line tools.
-In practice, you might write a program to fill the queue using an amqp client library.
+For this example, you will create the queue and fill it using the AMQP command line tools.
+In practice, you might write a program to fill the queue using an AMQP client library.
 -->
 
-本例中，如果有大量的数据需要被 Job 的所有 Pod 读取，典型的做法是把它们放在一个共享文件系统中，
+如果有大量的数据需要被 Job 的所有 Pod 读取，典型的做法是把它们放在一个共享文件系统中，
 如 NFS（Network File System 网络文件系统），并以只读的方式挂载到所有 Pod，或者 Pod 中的程序从类似 HDFS
 （Hadoop Distributed File System 分布式文件系统）的集群文件系统中读取。
 
-例如，我们创建队列并使用 amqp 命令行工具向队列中填充消息。实践中，你可以写个程序来利用 amqp 客户端库来填充这些队列。
+例如，你将创建队列并使用 AMQP 命令行工具向队列中填充消息。实践中，你可以写个程序来利用 AMQP 客户端库来填充这些队列。
+
+<!--
+# Run this on your computer, not in the Pod
+-->
+```shell
+# 在你的计算机上运行此命令，而不是在 Pod 中
+/usr/bin/amqp-declare-queue --url=$BROKER_URL -q job1  -d
+```
+```
+job1
+```
+<!--
+Add items to the queue:
+-->
+将这几项添加到队列中：
 
 ```shell
-/usr/bin/amqp-declare-queue --url=$BROKER_URL -q job1  -d job1
 for f in apple banana cherry date fig grape lemon melon
 do
   /usr/bin/amqp-publish --url=$BROKER_URL -r job1 -p -b $f
@@ -284,23 +323,23 @@ done
 ```
 
 <!--
-So, we filled the queue with 8 messages.
+You added 8 messages to the queue.
 
-## Create an Image
+## Create a container Image
 
-Now we are ready to create an image that we will run as a job.
+Now you are ready to create an image that you will run as a Job.
 
-We will use the `amqp-consume` utility to read the message
-from the queue and run our actual program.  Here is a very simple
+The job will use the `amqp-consume` utility to read the message
+from the queue and run the actual work.  Here is a very simple
 example program:
 -->
-这样，我们给队列中填充了 8 个消息。
+你给队列中填充了 8 个消息。
 
-## 创建镜像   {#create-an-image}
+## 创建容器镜像   {#create-a-container-image}
 
-现在我们可以创建一个做为 Job 来运行的镜像。
+现在你可以创建一个做为 Job 来运行的镜像。
 
-我们将用 `amqp-consume` 实用程序从队列中读取消息并运行实际的程序。
+这个 Job 将用 `amqp-consume` 实用程序从队列中读取消息并进行实际工作。
 这里给出一个非常简单的示例程序：
 
 {{% code_sample language="python" file="application/job/rabbitmq/worker.py" %}}
@@ -316,16 +355,13 @@ chmod +x worker.py
 
 
 <!--
-Now, build an image.  If you are working in the source
-tree, then change directory to `examples/job/work-queue-1`.
-Otherwise, make a temporary directory, change to it,
+Now, build an image. Make a temporary directory, change to it,
 download the [Dockerfile](/examples/application/job/rabbitmq/Dockerfile),
 and [worker.py](/examples/application/job/rabbitmq/worker.py).  In either case,
 build the image with this command:
 -->
 
-现在，编译镜像。如果你在用源代码树，那么切换到目录 `examples/job/work-queue-1`。
-否则的话，创建一个临时目录，切换到这个目录。下载
+现在，编译镜像。创建一个临时目录，切换到这个目录。下载
 [Dockerfile](/examples/application/job/rabbitmq/Dockerfile) 和
 [worker.py](/examples/application/job/rabbitmq/worker.py)。
 无论哪种情况，都可以用下面的命令编译镜像：
@@ -348,49 +384,48 @@ docker push <username>/job-wq-1
 ```
 
 <!--
-If you are using [Google Container
-Registry](https://cloud.google.com/tools/container-registry/), tag
-your app image with your project ID, and push to GCR. Replace
-`<project>` with your project ID.
+If you are using an alternative container image registry, tag the
+image and push it there instead.
 -->
-如果你在用[谷歌容器仓库](https://cloud.google.com/tools/container-registry/)，
-用你的项目 ID 作为标签打到你的应用镜像上，然后推送到 GCR。
-用你的项目 ID 替换 `<project>`。
-
-```shell
-docker tag job-wq-1 gcr.io/<project>/job-wq-1
-gcloud docker -- push gcr.io/<project>/job-wq-1
-```
+如果你使用替代的镜像仓库，请标记该镜像并将其推送到那里。
 
 <!--
 ## Defining a Job
 
 Here is a job definition.  You'll need to make a copy of the Job and edit the
 image to match the name you used, and call it `./job.yaml`.
+Here is a manifest for a Job.  You'll need to make a copy of the Job manifest
+(call it `./job.yaml`),
+and edit the name of the container image to match the name you used.
 -->
 ## 定义 Job   {#defining-a-job}
 
-这里给出一个 Job 定义 YAML 文件。你将需要拷贝一份 Job 并编辑该镜像以匹配你使用的名称，保存为 `./job.yaml`。
+这里给出一个 Job 的清单。你需要复制一份 Job 清单的副本（将其命名为 `./job.yaml`），
+并编辑容器镜像的名称以匹配使用的名称。
 
 {{% code_sample file="application/job/rabbitmq/job.yaml" %}}
 
 <!--
 In this example, each pod works on one item from the queue and then exits.
 So, the completion count of the Job corresponds to the number of work items
-done.  So we set, `.spec.completions: 8` for the example, since we put 8 items in the queue.
+done. That is why the example manifest has `.spec.completions` set to `8`.
 
 ## Running the Job
 
-So, now run the Job:
+Now, run the Job:
 -->
 本例中，每个 Pod 使用队列中的一个消息然后退出。
 这样，Job 的完成计数就代表了完成的工作项的数量。
-本例中我们设置 `.spec.completions: 8`，因为我们放了 8 项内容在队列中。
+这就是示例清单将 `.spec.completions` 设置为 `8` 的原因。
 
 ## 运行 Job   {#running-the-job}
 
-现在我们运行 Job：
+运行 Job：
 
+<!--
+# this assumes you downloaded and then edited the manifest already
+-->
+# 这假设你已经下载并编辑了清单
 ```shell
 kubectl apply -f ./job.yaml
 ```
@@ -422,14 +457,14 @@ Labels:           controller-uid=41d75705-92df-11e7-b85e-fa163ee3c11f
 Annotations:      <none>
 Parallelism:      2
 Completions:      8
-Start Time:       Wed, 06 Sep 2017 16:42:02 +0800
+Start Time:       Wed, 06 Sep 2022 16:42:02 +0000
 Pods Statuses:    0 Running / 8 Succeeded / 0 Failed
 Pod Template:
   Labels:       controller-uid=41d75705-92df-11e7-b85e-fa163ee3c11f
                 job-name=job-wq-1
   Containers:
    c:
-    Image:      gcr.io/causal-jigsaw-637/job-wq-1
+    Image:      container-registry.example/causal-jigsaw-637/job-wq-1
     Port:
     Environment:
       BROKER_URL:       amqp://guest:guest@rabbitmq-service:5672
@@ -450,49 +485,51 @@ Events:
 ```
 
 <!--
-All the pods for that Job succeeded. Yay.
+All the pods for that Job succeeded! You're done.
 -->
-该 Job 的所有 Pod 都已成功。耶！
+该 Job 的所有 Pod 都已成功！你完成了。
 
 <!-- discussion -->
 
 <!--
 ## Alternatives
 
-This approach has the advantage that you
-do not need to modify your "worker" program to be aware that there is a work queue.
+This approach has the advantage that you do not need to modify your "worker" program to be
+aware that there is a work queue.  You can include the worker program unmodified in your container
+image.
 
-It does require that you run a message queue service.
+Using this approach does require that you run a message queue service.
 If running a queue service is inconvenient, you may
 want to consider one of the other [job patterns](/docs/concepts/workloads/controllers/job/#job-patterns).
 -->
 ## 替代方案   {#alternatives}
 
 本文所讲述的处理方法的好处是你不需要修改你的 "worker" 程序使其知道工作队列的存在。
+你可以将未修改的工作程序包含在容器镜像中。
 
-本文所描述的方法需要你运行一个消息队列服务。如果不方便运行消息队列服务，
+使用此方法需要你运行消息队列服务。如果不方便运行消息队列服务，
 你也许会考虑另外一种[任务模式](/zh-cn/docs/concepts/workloads/controllers/job/#job-patterns)。
 
 <!--
 This approach creates a pod for every work item.  If your work items only take a few seconds,
 though, creating a Pod for every work item may add a lot of overhead.  Consider another
-[example](/docs/tasks/job/fine-parallel-processing-work-queue/), that executes multiple work items per Pod.
+design, such as in the [fine parallel work queue example](/docs/tasks/job/fine-parallel-processing-work-queue/), that executes multiple work items per Pod.
 
-In this example, we use the `amqp-consume` utility to read the message
-from the queue and run our actual program.  This has the advantage that you
+In this example, you use the `amqp-consume` utility to read the message
+from the queue and run the actual program.  This has the advantage that you
 do not need to modify your program to be aware of the queue.
-A [different example](/docs/tasks/job/fine-parallel-processing-work-queue/), shows how to
-communicate with the work queue using a client library.
+A [fine parallel work queue example](/docs/tasks/job/fine-parallel-processing-work-queue/)
+shows how to communicate with the work queue using a client library.
 -->
 本文所述的方法为每个工作项创建了一个 Pod。
 如果你的工作项仅需数秒钟，为每个工作项创建 Pod 会增加很多的常规消耗。
-可以考虑另外的方案请参考[示例](/zh-cn/docs/tasks/job/fine-parallel-processing-work-queue/)，
+考虑另一种设计，例如[精细并行工作队列示例](/zh-cn/docs/tasks/job/fine-parallel-processing-work-queue/)，
 这种方案可以实现每个 Pod 执行多个工作项。
 
-示例中，我们使用 `amqp-consume` 从消息队列读取消息并执行我们真正的程序。
+示例中，你使用了 `amqp-consume` 从消息队列读取消息并执行真正的程序。
 这样的好处是你不需要修改你的程序使其知道队列的存在。
 要了解怎样使用客户端库和工作队列通信，
-请参考[不同的示例](/zh-cn/docs/tasks/job/fine-parallel-processing-work-queue/)。
+请参考[精细并行工作队列示例](/zh-cn/docs/tasks/job/fine-parallel-processing-work-queue/)。
 
 <!--
 ## Caveats
@@ -504,11 +541,13 @@ If the number of completions is set to more than the number of items in the queu
 then the Job will not appear to be completed, even though all items in the queue
 have been processed.  It will start additional pods which will block waiting
 for a message.
+You would need to make your own mechanism to spot when there is work
+to do and measure the size of the queue, setting the number of completions to match.
 
 There is an unlikely race with this pattern.  If the container is killed in between the time
-that the message is acknowledged by the amqp-consume command and the time that the container
+that the message is acknowledged by the `amqp-consume` command and the time that the container
 exits with success, or if the node crashes before the kubelet is able to post the success of the pod
-back to the api-server, then the Job will not appear to be complete, even though all items
+back to the API server, then the Job will not appear to be complete, even though all items
 in the queue have been processed.
 -->
 ## 友情提醒   {#caveats}
@@ -517,7 +556,8 @@ in the queue have been processed.
 
 如果设置的完成数量大于队列中的消息数量，当队列中所有的消息都处理完成后，
 Job 也会显示为未完成。Job 将创建 Pod 并阻塞等待消息输入。
+你需要建立自己的机制来发现何时有工作要做，并测量队列的大小，设置匹配的完成数量。
 
 当发生下面两种情况时，即使队列中所有的消息都处理完了，Job 也不会显示为完成状态：
-* 在 amqp-consume 命令拿到消息和容器成功退出之间的时间段内，执行杀死容器操作；
-* 在 kubelet 向 api-server 传回 Pod 成功运行之前，发生节点崩溃。
+* 在 `amqp-consume` 命令拿到消息和容器成功退出之间的时间段内，执行杀死容器操作；
+* 在 kubelet 向 API 服务器传回 Pod 成功运行之前，发生节点崩溃。