diff --git a/content/ja/docs/concepts/overview/what-is-kubernetes.md b/content/ja/docs/concepts/overview/what-is-kubernetes.md
index 054930e426..5f2f4bbf18 100644
--- a/content/ja/docs/concepts/overview/what-is-kubernetes.md
+++ b/content/ja/docs/concepts/overview/what-is-kubernetes.md
@@ -1,8 +1,11 @@
 ---
+reviewers:
 title: Kubernetesとは何か？
+description: >
+  Kubernetesは、宣言的な構成管理と自動化を促進し、コンテナ化されたワークロードやサービスを管理するための、ポータブルで拡張性のあるオープンソースのプラットフォームです。Kubernetesは巨大で急速に成長しているエコシステムを備えており、それらのサービス、サポート、ツールは幅広い形で利用可能です。
 content_type: concept
 weight: 10
-card: 
+card:
   name: concepts
   weight: 10
 ---
@@ -12,94 +15,76 @@ card:
 
 
 <!-- body -->
-Kubernetesは、宣言的な構成管理と自動化を促進し、コンテナ化されたワークロードやサービスを管理するための、ポータブルで拡張性のあるオープンソースプラットホームです。
+Kubernetesは、宣言的な構成管理と自動化を促進し、コンテナ化されたワークロードやサービスを管理するための、ポータブルで拡張性のあるオープンソースのプラットフォームです。Kubernetesは巨大で急速に成長しているエコシステムを備えており、それらのサービス、サポート、ツールは幅広い形で利用可能です。
 
-Kubernetesは膨大で、急速に成長しているエコシステムを備えており、それらのサービス、サポート、ツールは幅広い形で利用可能です。
+Kubernetesの名称は、ギリシャ語に由来し、操舵手やパイロットを意味しています。Googleは2014年にKubernetesプロジェクトをオープンソース化しました。Kubernetesは、本番環境で大規模なワークロードを稼働させた[Googleの15年以上の経験](/blog/2015/04/borg-predecessor-to-kubernetes/)と、コミュニティからの最高のアイディアや実践を組み合わせています。
 
-Googleは2014年にKubernetesプロジェクトをオープンソース化しました。Kubernetesは[Googleが大規模な本番ワークロードを動かしてきた10年半の経験](https://research.google.com/pubs/pub43438.html)と、コミュニティから得られた最善のアイデア、知見に基づいています。
+## 過去を振り返ってみると
 
-## なぜKubernetesが必要で、どんなことができるのか？
+過去を振り返って、Kubernetesがなぜこんなに便利なのかを見てみましょう。
 
-Kubernetesには多くの機能があります。考えられるものとしては
+![Deployment evolution](/images/docs/Container_Evolution.svg)
 
-- コンテナ基盤
-- マイクロサービス基盤
-- ポータブルなクラウド基盤
+**仮想化ができる前の時代におけるデプロイ (Traditional deployment):** 初期の頃は、組織は物理サーバー上にアプリケーションを実行させていました。物理サーバー上でアプリケーションのリソース制限を設定する方法がなかったため、リソースの割当問題が発生していました。例えば、複数のアプリケーションを実行させた場合、ひとつのアプリケーションがリソースの大半を消費してしまうと、他のアプリケーションのパフォーマンスが低下してしまうことがありました。この解決方法は、それぞれのアプリケーションを別々の物理サーバーで動かすことでした。しかし、リソースが十分に活用できなかったため、拡大しませんでした。また組織にとって多くの物理サーバーを維持することは費用がかかりました。
 
-など、他にもいろいろ
+**仮想化を使ったデプロイ (Virtualized deployment):** ひとつの解決方法として、仮想化が導入されました。1台の物理サーバーのCPU上で、複数の仮想マシン(VM)を実行させることができるようになりました。仮想化によりアプリケーションをVM毎に隔離する事ができ、ひとつのアプリケーションの情報が他のアプリケーションから自由にアクセスさせないといったセキュリティレベルを提供することができます。
 
-Kubernetesは、**コンテナを中心とした**管理基盤です。ユーザーワークロードの代表格であるコンピューティング、ネットワーキング、ストレージインフラストラクチャのオーケストレーションを行います。それによって、Platform as a Service(PaaS)の簡単さの大部分を、Infrastructure as a Service(IaaS)の柔軟さとともに提供し、インフラストラクチャプロバイダの垣根を超えたポータビリティを実現します。
+仮想化により、物理サーバー内のリソース使用率が向上し、アプリケーションの追加や更新が容易になり、ハードウェアコストの削減などスケーラビリティが向上します。仮想化を利用すると、物理リソースのセットを使い捨て可能な仮想マシンのクラスターとして提示することができます。
 
-## Kubernetesが基盤になるってどういうこと？
+各VMは、仮想ハードウェア上で各自のOSを含んだ全コンポーネントを実行する完全なマシンです。
 
-Kubernetesが多くの機能を提供すると言いつつも、新しい機能から恩恵を受ける新しいシナリオは常にあります。アプリケーション固有のワークフローを効率化して開発者のスピードを早めることができます。最初は許容できるアドホックなオーケストレーションでも、大規模で堅牢な自動化が必要となることはしばしばあります。これが、Kubernetesがアプリケーションのデプロイ、拡張、および管理を容易にするために、コンポーネントとツールのエコシステムを構築するための基盤としても機能するように設計された理由です。
+**コンテナを使ったデプロイ (Container deployment):** コンテナはVMと似ていますが、アプリケーション間でオペレーティング・システム(OS)を共有できる緩和された分離特性を持っています。そのため、コンテナは軽量だといわれます。VMと同じように、コンテナは各自のファイルシステム、CPU、メモリー、プロセス空間等を持っています。基盤のインフラストラクチャから分離されているため、クラウドやOSディストリビューションを越えて移動することが可能です。
 
-[ラベル](/ja/docs/concepts/overview/working-with-objects/labels/)を使用すると、ユーザーは自分のリソースを整理できます。[アノテーション](/ja/docs/concepts/overview/working-with-objects/annotations/)を使用すると、ユーザーは自分のワークフローを容易にし、管理ツールが状態をチェックするための簡単な方法を提供するためにカスタムデータを使ってリソースを装飾できるようになります。
+コンテナは、その他にも次のようなメリットを提供するため、人気が高まっています。
 
-さらに、[Kubernetesコントロールプレーン](/ja/docs/concepts/overview/components/)は、開発者やユーザーが使える[API](/docs/reference/using-api/api-overview/)の上で成り立っています。ユーザーは[スケジューラー](https://github.com/kubernetes/community/blob/{{< param "githubbranch" >}}/contributors/devel/scheduler.md)などの独自のコントローラーを、汎用の[コマンドラインツール](/docs/user-guide/kubectl-overview/)で使える[独自のAPI](/docs/concepts/api-extension/custom-resources/)を持たせて作成することができます。
+* アジャイルアプリケーションの作成とデプロイ: VMイメージの利用時と比較して、コンテナイメージ作成の容易さと効率性が向上します。
+* 継続的な開発、インテグレーションとデプロイ: 信頼できる頻繁なコンテナイメージのビルドと、素早く簡単にロールバックすることが可能なデプロイを提供します。(イメージが不変であれば)
+* 開発者と運用者の関心を分離: アプリケーションコンテナイメージの作成は、デプロイ時ではなく、ビルド/リリース時に行います。それによって、インフラストラクチャとアプリケーションを分離します。
+* 可観測性はOSレベルの情報とメトリクスだけではなく、アプリケーションの稼働状態やその他の警告も表示します。
+* 開発、テスト、本番環境を越えた環境の一貫性: クラウドで実行させるのと同じようにノートPCでも実行させる事ができます。
+* クラウドとOSディストリビューションの可搬性: Ubuntu、RHEL、CoreOS上でも、オンプレミスも、主要なパブリッククラウドでも、それ以外のどんな環境でも、実行できます。
+* アプリケーション中心の管理: 仮想マシン上でOSを実行するから、論理リソースを使用してOS上でアプリケーションを実行するへと抽象度のレベルを向上させます。
+* 疎結合、分散化、拡張性、柔軟性のあるマイクロサービス: アプリケーションを小さく、同時にデプロイと管理が可能な独立した部品に分割されます。1台の大きな単一目的のマシン上に実行するモノリシックなスタックではありません。
+* リソースの分割: アプリケーションのパフォーマンスが予測可能です。
+* リソースの効率的な利用: 高い効率性と集約性が可能です。
 
-この[デザイン](https://git.k8s.io/community/contributors/design-proposals/architecture/architecture.md)によって、他の多くのシステムがKubernetes上で構築できるようになりました。
+## Kubernetesが必要な理由と提供する機能 {#why-you-need-kubernetes-and-what-can-it-do}
 
-## Kubernetesにないこと
+コンテナは、アプリケーションを集約して実行する良い方法です。本番環境では、アプリケーションを実行しダウンタイムが発生しないように、コンテナを管理する必要があります。例えば、コンテナがダウンした場合、他のコンテナを起動する必要があります。このような動作がシステムに組込まれていると、管理が簡単になるのではないでしょうか？
 
-Kubernetesは伝統的な何でも入りのPaaSシステムではありません。Kubernetesはハードウェアレベルではなくコンテナレベルで動作するため、PaaS製品が提供するような、共通のいくつかの一般的に適用可能な機能(デプロイ、拡張、負荷分散、ログ記録、監視など)を提供します。ただし、Kubernetesはモノリシックではなく、これらのデフォルトのソリューションは任意に脱着可能です。Kubernetesは開発者の基盤を構築するための構成要素を提供しますが、重要な場合はユーザーの選択と柔軟性を維持します。
+そこを助けてくれるのがKubernetesです! Kubernetesは分散システムを弾力的に実行するフレームワークを提供してくれます。あなたのアプリケーションのためにスケーリングとフェイルオーバーの面倒を見てくれて、デプロイのパターンなどを提供します。例えば、Kubernetesはシステムにカナリアデプロイを簡単に管理することができます。
+
+Kubernetesは以下を提供します。
+
+* **サービスディスカバリーと負荷分散**  
+Kubernetesは、DNS名または独自のIPアドレスを使ってコンテナを公開することができます。コンテナへのトラフィックが多い場合は、Kubernetesは負荷分散し、ネットワークトラフィックを振り分けることができるたため、デプロイが安定します。
+* **ストレージ オーケストレーション**  
+Kubernetesは、ローカルストレージやパブリッククラウドプロバイダーなど、選択したストレージシステムを自動でマウントすることができます。
+* **自動化されたロールアウトとロールバック**  
+Kubernetesを使うとデプロイしたコンテナのあるべき状態を記述することができ、制御されたスピードで実際の状態をあるべき状態に変更することができます。例えば、アプリケーションのデプロイのために、新しいコンテナの作成や既存コンテナの削除、新しいコンテナにあらゆるリソースを適用する作業を、Kubernetesで自動化できます。
+* **自動ビンパッキング**  
+コンテナ化されたタスクを実行するノードのクラスターをKubernetesへ提供します。各コンテナがどれくらいCPUやメモリー(RAM)を必要とするのかをKubernetesに宣言することができます。Kubernetesはコンテナをノードにあわせて調整することができ、リソースを最大限に活用してくれます。
+* **自己修復**  
+Kubernetesは、処理が失敗したコンテナを再起動し、コンテナを入れ替え、定義したヘルスチェックに応答しないコンテナを強制終了します。処理の準備ができるまでは、クライアントに通知しません。
+* **機密情報と構成管理**  
+Kubernetesは、パスワードやOAuthトークン、SSHキーのよう機密の情報を保持し、管理することができます。機密情報をデプロイし、コンテナイメージを再作成することなくアプリケーションの構成情報を更新することができます。スタック構成の中で機密情報を晒してしまうこともありません。
+
+## Kubernetesにないもの
+
+Kubernetesは、従来型の全部入りなPaaS(Platform as a Service)のシステムではありません。Kubernetesはハードウェアレベルではなく、コンテナレベルで動作するため、デプロイ、スケーリング、負荷分散、ロギングやモニタリングといったPasSが提供するのと共通の機能をいくつか提供しています。また一方、Kubernetesはモノリシックでなく、標準のソリューションは選択が自由で、追加と削除が容易な構成になっています。Kubernetesは開発プラットフォーム構築のためにビルディングブロックを提供しますが、重要な部分はユーザーの選択と柔軟性を維持しています。
 
 Kubernetesは...
 
-* サポートするアプリケーションの種類を限定しません。Kubernetesはステートレス、ステートフル、およびデータ処理ワークロードなど、非常に多様なワークロードをサポートするように作られています。アプリケーションをコンテナ内で実行できる場合は、Kubernetes上でもうまく動作するはずです。
-* ソースコードのデプロイやアプリケーションのビルドを行いません。継続的インテグレーション、デリバリー、デプロイ(CI/CD)ワークフローは、技術選定がそうであるように、組織の文化や好みによって決まるからです。
-* ミドルウェア(例: メッセージバス)、データ処理フレームワーク(例: Spark)、データベース(例: mysql)、キャッシュ、クラスターストレージシステム(例: Ceph) のような、アプリケーションレベルの機能は組み込みでは提供しません。これらのコンポーネントはKubernetesの上で動作できますし、Open Service Brokerのようなポータブルメカニズムを経由してKubernetes上のアプリケーションからアクセスすることもできます。
-* ロギング、モニタリング、アラーティングソリューションへの指示は行いません。概念実証(PoC)としていくつかのインテグレーション、およびメトリックを収集およびエクスポートするためのメカニズムを提供します。
-* 設定言語/システム(例： jsonnet)を提供も強制もしません。任意の形式の宣言仕様の対象となる可能性がある宣言APIを提供します。
-* 包括的なインフラ構成、保守、管理、またはセルフヒーリングシステムを提供、導入しません。
-
-さらに、Kubernetesは単なる *オーケストレーションシステム* ではありません。実際、オーケストレーションは不要です。*オーケストレーション* の技術的定義は、定義されたワークフローの実行です。最初にA、次にB、次にCを実行します。対照的に、Kubernetesは現在の状態を提供された望ましい状態に向かって継続的に推進する一連の独立した構成可能な制御プロセスで構成されます。AからCへのアクセス方法は関係ありません。集中管理も必要ありません。これにより、使いやすく、より強力で、堅牢で、回復力があり、そして拡張性のあるシステムが得られます。
-
-## なぜコンテナなのか？
-
-コンテナを使うべき理由をお探しですか？
-
-![なぜコンテナなのか？](/images/docs/why_containers.svg)
-
-アプリケーションをデプロイするための古い方法は、オペレーティングシステムのパッケージマネージャを使用してアプリケーションをホストにインストールすることでした。これには、アプリケーションの実行ファイル、構成、ライブラリ、ライフサイクルがそれぞれ、またホストOS自身と絡み合うというデメリットがありました。予測可能なロールアウトとロールバックを実現するために、不変の仮想マシンイメージを作成することもできますが、VMは重く、移植性がありません。
-
-新しい方法は、ハードウェア仮想化ではなく、オペレーティングシステムレベルの仮想化に基づいてコンテナを展開することです。各コンテナは互いに、そしてホストから隔離されています。また、独自のファイルシステムを持ち、お互いのプロセスを見ることができず、計算リソースの使用量を制限することができます。これはVMよりも構築が簡単で、基盤となるインフラストラクチャとホストのファイルシステムから分離されているため、クラウドやOSのディストリビューション間で移植性があります。
-
-コンテナは小さくて速いので、1つのアプリケーションを各コンテナイメージにまとめることができます。この1対1のアプリケーションとイメージの関係により、コンテナの利点が完全に引き出されます。コンテナを使用すると、各アプリケーションを残りのアプリケーションスタックと合成したり、本番インフラストラクチャ環境と結合したりする必要がないため、不変のコンテナイメージをデプロイ時ではなく、ビルド時またはリリース時に作成できます。ビルド/リリース時にコンテナイメージを生成することで、開発から運用に一貫した環境を持ち込むことができます。同様に、コンテナはVMよりもはるかに透過的であるため、監視と管理が容易になります。これは、コンテナのプロセスライフサイクルがコンテナ内のプロセススーパーバイザによって隠されるのではなく、インフラストラクチャによって管理される場合に特に当てはまります。最後に、コンテナごとに1つのアプリケーションを使用すると、コンテナの管理はアプリケーションのデプロイ管理と同等になります。
-
-コンテナの利点をまとめると:
-
-* **アジャイルなアプリケーション作成とデプロイ**:
-    VMイメージの使用と比べ、コンテナイメージ作成は容易で効率も高いです。
-* **継続的な開発、インテグレーション、デプロイ**:
-    迅速で簡単なロールバックで、信頼性の高い頻繁なコンテナイメージのビルドとデプロイを提供します(イメージの不変性にもよります)。
-* **開発と運用の懸念を分離**:
-    デプロイ時ではなくビルド時またはリリース時にアプリケーションのコンテナイメージを作成することで、アプリケーションをインフラストラクチャから切り離します。
-* **可観測性**
-    OSレベルの情報や測定基準だけでなく、アプリケーションの正常性やその他のシグナルも明確にします。
-* **開発、テスト、本番環境に跨った環境の一貫性**:
-    手元のノートPC上でも、クラウド上と同じように動作します。
-* **クラウドとOSディストリビューションの移植性**:
-    Ubuntu、RHEL、CoreOS、オンプレミス、Google Kubernetes Engine、その他のどこでも動作します。
-* **アプリケーション中心の管理**:
-    仮想ハードウェア上でのOS実行から、論理リソースを使用したOS上でのアプリケーション実行へと、抽象度のレベルを上げます。
-* **疎結合で、分散された、伸縮自在の遊離した[マイクロサービス](https://martinfowler.com/articles/microservices.html)**:
-    アプリケーションは小さな独立した欠片に分割され、動的に配置および管理できます。1つの大きな単一目的のマシンで実行されるモノリシックなスタックではありません。
-* **リソース分割**:
-    アプリケーションパフォーマンスが予測可能です。
-* **リソースの効率利用**:
-    高効率で高密度です。
-
-## Kubernetesってどういう意味？K8sって何？
-
-**Kubernetes** という名前はギリシャ語で *操舵手* や *パイロット* という意味があり、*知事* や[サイバネティックス](http://www.etymonline.com/index.php?term=cybernetics)の語源にもなっています。*K8s* は、8文字の「ubernete」を「8」に置き換えた略語です。
-
+* サポートするアプリケーションの種類を制限しません。Kubernetesは、スレートレス、ステートフルやデータ処理のワークロードなど、非常に多様なワークロードをサポートすることを目的としています。アプリケーションがコンテナで実行できるのであれば、Kubernetes上で問題なく実行できるはずです。
+* ソースコードのデプロイやアプリケーションのビルドは行いません。継続的なインテグレーション、デリバリー、デプロイ(CI/CD)のワークフローは、技術的な要件だけでなく組織の文化や好みで決められます。
+* ミドルウェア(例:メッセージバス)、データ処理フレームワーク(例:Spark)、データベース(例:MySQL)、キャッシュ、クラスターストレージシステム(例:Ceph)といったアプリケーションレベルの機能を組み込んで提供しません。それらのコンポーネントは、Kubernetes上で実行することもできますし、[Open Service Broker](https://openservicebrokerapi.org/)のようなポータブルメカニズムを経由してKubernetes上で実行されるアプリケーションからアクセスすることも可能です。
+* ロギング、モニタリングやアラートを行うソリューションは指定しません。PoCとしていくつかのインテグレーションとメトリクスを収集し出力するメカニズムを提供します。
+* 構成言語/システム(例:Jsonnet)の提供も指示もしません。任意の形式の宣言型仕様の対象となる可能性のある宣言型APIを提供します。
+* 統合的なマシンの構成、メンテナンス、管理、または自己修復を行うシステムは提供も採用も行いません。
+* さらに、Kubernetesは単なるオーケストレーションシステムではありません。実際には、オーケストレーションの必要性はありません。オーケストレーションの技術的な定義は、「最初にAを実行し、次にB、その次にCを実行」のような定義されたワークフローの実行です。対照的にKubernetesは、現在の状態から提示されたあるべき状態にあわせて継続的に維持するといった、独立していて構成可能な制御プロセスのセットを提供します。AからCへどのように移行するかは問題ではありません。集中管理も必要ありません。これにより、使いやすく、より強力で、堅牢で、弾力性と拡張性があるシステムが実現します。
 
 
 ## {{% heading "whatsnext" %}}
 
-*   [はじめる](/docs/setup/)準備はできましたか？
-*   さらなる詳細については、[Kubernetesのドキュメント](/ja/docs/home/)を御覧ください。
-
-
-
+*   [Kubernetesのコンポーネント](/ja/docs/concepts/overview/components/)を御覧ください。
+*   [はじめる](/ja/docs/setup/)準備はできましたか？
diff --git a/content/ja/docs/setup/learning-environment/minikube.md b/content/ja/docs/setup/learning-environment/minikube.md
index 543256b4e3..c5f57ecfb9 100644
--- a/content/ja/docs/setup/learning-environment/minikube.md
+++ b/content/ja/docs/setup/learning-environment/minikube.md
@@ -1,143 +1,257 @@
 ---
 title: Minikubeを使用してローカル環境でKubernetesを動かす
+weight: 30
 content_type: concept
 ---
 
+
 <!-- overview -->
 
 Minikubeはローカル環境でKubernetesを簡単に実行するためのツールです。Kubernetesを試したり日々の開発への使用を検討するユーザー向けに、PC上のVM内でシングルノードのKubernetesクラスタを実行することができます。
 
 
-
 <!-- body -->
 
 ## Minikubeの機能
 
-* MinikubeのサポートするKubernetesの機能:
-  * DNS
-  * NodePorts
-  * ConfigMapsとSecrets
-  * ダッシュボード
-  * コンテナランタイム: Docker, [rkt](https://github.com/rkt/rkt), [CRI-O](https://cri-o.io/), [containerd](https://github.com/containerd/containerd)
-  * CNI (Container Network Interface) の有効化
-  * Ingress
+MinikubeのサポートするKubernetesの機能:
+
+* DNS
+* NodePort
+* ConfigMapとSecret
+* ダッシュボード
+* コンテナランタイム: Docker、[CRI-O](https://cri-o.io/)および[containerd](https://github.com/containerd/containerd)
+* CNI (Container Network Interface) の有効化
+* Ingress
 
 ## インストール
 
-[Minikubeのインストール](/ja/docs/tasks/tools/install-minikube/) を参照
+[Minikubeのインストール](/ja/docs/tasks/tools/install-minikube/)を参照してください。
 
 ## クイックスタート
 
-これはMinikubeの使い方の簡単なデモです。
-もしVMドライバを変更したい場合は、適切な `--vm-driver=xxx` フラグを `minikube start` に設定してください。Minikubeは以下のドライバをサポートしています。
+これはMinikubeの起動、使用、削除をローカルで実施する簡単なデモです。下記の手順に従って、Minikubeを起動し試してください。
 
-* virtualbox
+1. Minikubeを起動し、クラスターを作成します:
+
+   ```shell
+   minikube start
+   ```
+
+   出力はこのようになります:
+
+   ```
+   Starting local Kubernetes cluster...
+   Running pre-create checks...
+   Creating machine...
+   Starting local Kubernetes cluster...
+   ```
+
+   特定のKubernetesのバージョン、VM、コンテナランタイム上でクラスターを起動するための詳細は、[クラスターの起動](#starting-a-cluster)を参照してください。
+
+2. kubectlを使用してクラスターと対話できるようになります。詳細は[クラスターに触れてみよう](#interacting-with-your-cluster)を参照してください。
+単純なHTTPサーバーである`echoserver`という既存のイメージを使用して、Kubernetes Deploymentを作りましょう。そして`--port`を使用して8080番ポートで公開しましょう。
+
+   ```shell
+   kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.10
+   ```
+
+   出力はこのようになります:
+
+   ```
+   deployment.apps/hello-minikube created
+   ```
+
+3. `hello-minikube`Deploymentに接続するために、Serviceとして公開します:
+
+   ```shell
+   kubectl expose deployment hello-minikube --type=NodePort --port=8080
+   ```
+
+   `--type=NodePort`オプションで、Serviceのタイプを指定します。
+   出力はこのようになります:
+
+   ```
+   service/hello-minikube exposed
+   ```
+
+4. `hello-minikube`Podが起動開始されましたが、公開したService経由で接続する前にPodが起動完了になるまで待つ必要があります。
+
+   Podが稼働しているか確認します:
+   ```shell
+   kubectl get pod
+   ```
+
+   `STATUS`に`ContainerCreating`と表示されている場合、Podはまだ作成中です:
+
+   ```
+   NAME                              READY     STATUS              RESTARTS   AGE
+   hello-minikube-3383150820-vctvh   0/1       ContainerCreating   0          3s
+   ```
+
+   `STATUS`に`Running`と表示されている場合、Podは稼働中です:
+
+   ```
+   NAME                              READY     STATUS    RESTARTS   AGE
+   hello-minikube-3383150820-vctvh   1/1       Running   0          13s
+   ```
+
+5. Serviceの詳細を確認するため、公開したServiceのURLを取得します:
+
+   ```shell
+   minikube service hello-minikube --url
+   ```
+
+6. ローカル環境のクラスターについて詳細を確認するには、出力から得たURLをブラウザー上でコピーアンドペーストしてください。
+
+   出力はこのようになります:
+
+   ```
+   Hostname: hello-minikube-7c77b68cff-8wdzq
+   
+   Pod Information:
+   	-no pod information available-
+   
+   Server values:
+   	server_version=nginx: 1.13.3 - lua: 10008
+   
+   Request Information:
+   	client_address=172.17.0.1
+   	method=GET
+   	real path=/
+   	query=
+   	request_version=1.1
+   	request_scheme=http
+   	request_uri=http://192.168.99.100:8080/
+   
+   Request Headers:
+   	accept=*/*
+   	host=192.168.99.100:30674
+   	user-agent=curl/7.47.0
+   
+   Request Body:
+   	-no body in request-
+   ```
+
+   Serviceやクラスターをこれ以上稼働させない場合、削除する事ができます。
+
+7. `hello-minikube`Serviceを削除します:
+
+   ```shell
+   kubectl delete services hello-minikube
+   ```
+
+   出力はこのようになります:
+
+   ```
+   service "hello-minikube" deleted
+   ```
+
+8. `hello-minikube`Deploymentを削除します:
+
+   ```shell
+   kubectl delete deployment hello-minikube
+   ```
+
+   出力はこのようになります:
+
+   ```
+   deployment.extensions "hello-minikube" deleted
+   ```
+
+9. ローカル環境のMinikubeクラスターを停止します:
+
+   ```shell
+   minikube stop
+   ```
+
+   出力はこのようになります:
+
+   ```
+   Stopping local Kubernetes cluster...
+   Stopping "minikube"...
+   ```
+
+   詳細は[クラスターの停止](#stopping-a-cluster)を参照ください。
+
+10. ローカルのMinikubeクラスターを削除します:
+
+    ```shell
+    minikube delete
+    ```
+
+    出力はこのようになります:
+
+    ```
+    Deleting "minikube" ...
+    The "minikube" cluster has been deleted.
+    ```
+
+    詳細は[クラスターの削除](#deleting-a-cluster)を参照ください。
+
+## クラスターの管理
+
+### クラスターの起動 {#starting-a-cluster}
+
+`minikube start`コマンドを使用してクラスターを起動することができます。
+このコマンドはシングルノードのKubernetesクラスターを実行する仮想マシンを作成・設定します。
+また、このクラスターと通信する[kubectl](/ja/docs/reference/kubectl/overview/)のインストールも設定します。
+
+{{< note >}}
+もしWebプロキシーを通している場合、そのプロキシー情報を`minikube start`コマンドに渡す必要があります:
+
+```shell
+https_proxy=<my proxy> minikube start --docker-env http_proxy=<my proxy> --docker-env https_proxy=<my proxy> --docker-env no_proxy=192.168.99.0/24
+```
+
+残念なことに、ただ環境変数を設定するだけではうまく動作しません。
+
+Minikubeは"minikube"コンテキストも作成し、そのコンテキストをデフォルト設定としてkubectlに設定します。
+あとでコンテキストを切り戻すには、このコマンドを実行してください: `kubectl config use-context minikube`
+{{< /note >}}
+
+#### Kubernetesバージョンの指定
+
+`minikube start`コマンドに`--kubernetes-version`文字列を追加することで、
+MinikubeにKubernetesの特定のバージョンを指定することができます。
+例えば、{{< param "fullversion" >}}のバージョンを実行するには以下を実行します:
+
+```
+minikube start --kubernetes-version {{< param "fullversion" >}}
+```
+
+#### VMドライバーの指定
+
+もしVMドライバーを変更したい場合は、`--vm-driver=<enter_driver_name>`フラグを`minikube start`に設定してください。例えば、コマンドは以下のようになります。
+
+```shell
+minikube start --vm-driver=<driver_name>
+```
+
+Minikubeは以下のドライバーをサポートしています:
+ {{< note >}}
+サポートされているドライバーとプラグインのインストールの詳細については[DRIVERS](https://git.k8s.io/minikube/docs/drivers.md)を参照してください。
+{{< /note >}}
+
+* virtualbox  
 * vmwarefusion
 * kvm2 ([driver installation](https://git.k8s.io/minikube/docs/drivers.md#kvm2-driver))
-* kvm ([driver installation](https://git.k8s.io/minikube/docs/drivers.md#kvm-driver))
 * hyperkit ([driver installation](https://git.k8s.io/minikube/docs/drivers.md#hyperkit-driver))
-* xhyve ([driver installation](https://git.k8s.io/minikube/docs/drivers.md#xhyve-driver)) (非推奨)
 * hyperv ([driver installation](https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#hyperv-driver))
-注意: 以下のIPは動的であり、変更される可能性があります。IPは `minikube ip` で取得することができます。
-* none (VMではなくホスト上でKubernetesコンポーネントを起動する。このドライバを使用するにはDocker ([docker install](https://docs.docker.com/install/linux/docker-ce/ubuntu/)) とLinux環境を必要とします)
+注意: 以下のIPは動的であり、変更される可能性があります。IPは`minikube ip`で取得することができます。
+* vmware ([driver installation](https://minikube.sigs.k8s.io/docs/reference/drivers/vmware/)) (VMware unified driver)
+* none (VMではなくホスト上でKubernetesコンポーネントを起動。このドライバーを使用するには{{< glossary_tooltip term_id="docker" >}}とLinux環境を必要とします)
 
-```shell
-minikube start
-```
-```
-Starting local Kubernetes cluster...
-Running pre-create checks...
-Creating machine...
-Starting local Kubernetes cluster...
-```
-```shell
-kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.10
-```
-```
-deployment.apps/hello-minikube created
-```
-
-```shell
-kubectl expose deployment hello-minikube --type=NodePort --port=8080
-```
-```
-service/hello-minikube exposed
-```
-```
-# We have now launched an echoserver pod but we have to wait until the pod is up before curling/accessing it
-# via the exposed service.
-# To check whether the pod is up and running we can use the following:
-kubectl get pod
-```
-```
-NAME                              READY     STATUS              RESTARTS   AGE
-hello-minikube-3383150820-vctvh   0/1       ContainerCreating   0          3s
-```
-```shell
-# We can see that the pod is still being created from the ContainerCreating status
-kubectl get pod
-```
-```
-NAME                              READY     STATUS    RESTARTS   AGE
-hello-minikube-3383150820-vctvh   1/1       Running   0          13s
-```
-```shell
-# We can see that the pod is now Running and we will now be able to curl it:
-curl $(minikube service hello-minikube --url)
-```
-```
-
-Hostname: hello-minikube-7c77b68cff-8wdzq
-
-Pod Information:
-	-no pod information available-
-
-Server values:
-	server_version=nginx: 1.13.3 - lua: 10008
-
-Request Information:
-	client_address=172.17.0.1
-	method=GET
-	real path=/
-	query=
-	request_version=1.1
-	request_scheme=http
-	request_uri=http://192.168.99.100:8080/
-
-Request Headers:
-	accept=*/*
-	host=192.168.99.100:30674
-	user-agent=curl/7.47.0
-
-Request Body:
-	-no body in request-
-```
-
-```shell
-kubectl delete services hello-minikube
-```
-```
-service "hello-minikube" deleted
-```
-
-```shell
-kubectl delete deployment hello-minikube
-```
-```
-deployment.extensions "hello-minikube" deleted
-```
-
-```shell
-minikube stop
-```
-```
-Stopping local Kubernetes cluster...
-Stopping "minikube"...
-```
+{{< caution >}}
+`none`ドライバーを使用する場合、一部のKubernetesのコンポーネントは特権付きのコンテナとして稼働するため、Minikube環境外に副作用をもたらします。
+この副作用から、`none`ドライバーは、個人の作業環境では推奨されません。
+{{< /caution >}}
 
 ### コンテナランタイムの代替
+下記のコンテナランタイム上でMinikubeを起動できます。
 
-#### containerd
+{{< tabs name="container_runtimes" >}}
+{{% tab name="containerd" %}}
 
 [containerd](https://github.com/containerd/containerd) をコンテナランタイムとして使用するには以下を実行してください:
 
@@ -160,10 +274,9 @@ minikube start \
     --extra-config=kubelet.image-service-endpoint=unix:///run/containerd/containerd.sock \
     --bootstrapper=kubeadm
 ```
-
-#### CRI-O
-
-[CRI-O](https://github.com/kubernetes-incubator/cri-o) をコンテナランタイムとして使用するには以下を実行してください:
+{{% /tab %}}
+{{% tab name="CRI-O" %}}
+[CRI-O](https://cri-o.io/)をコンテナランタイムとして使用するには以下を実行してください:
 
 ```bash
 minikube start \
@@ -184,47 +297,33 @@ minikube start \
     --extra-config=kubelet.image-service-endpoint=/var/run/crio.sock \
     --bootstrapper=kubeadm
 ```
-
-#### rktコンテナエンジン
-
-[rkt](https://github.com/rkt/rkt) をコンテナランタイムとして使用するには以下を実行してください:
-
-```shell
-minikube start \
-    --network-plugin=cni \
-    --enable-default-cni \
-    --container-runtime=rkt
-```
-
-これはrktとDockerの両方を含んだ代替のMinikubeのISOイメージを使用し、CNIネットワークを有効にします。
-
-### ドライバープラグイン
-
-サポートされているドライバとプラグインのインストールの詳細については [DRIVERS](https://git.k8s.io/minikube/docs/drivers.md) を参照してください。
+{{% /tab %}}
+{{< /tabs >}}
 
 ### Dockerデーモンの再利用によるローカルイメージの使用
 
-Kubernetesの単一のVMを使用する場合、Minikube組み込みのDockerデーモンの再利用がおすすめです。ホストマシン上にDockerレジストリを構築してイメージをプッシュする必要がなく、ローカルでの実験を加速させるMinikubeと同じDockerデーモンの中に構築することができます。ただDockerイメージに'latest'以外のタグを付け、そのタグを使用してイメージをプルしてください。イメージのバージョンを指定しなければ、`Always` のプルイメージポリシーにより `:latest` と仮定され、もしデフォルトのDockerレジストリ(通常はDockerHub)にどのバージョンのDockerイメージもまだ存在しない場合には、`ErrImagePull` になる恐れがあります。
+Kubernetesの単一のVMを使用する場合、Minikube組み込みのDockerデーモンの再利用がおすすめです。ホストマシン上にDockerレジストリを構築してイメージをプッシュする必要がなく、ローカルでの実験を加速させるMinikubeと同じDockerデーモンの中に構築することができます。
 
-Mac/LinuxのホストでDockerデーモンを操作できるようにするには、shell内で `docker-env command` を使います:
+{{< note >}}
+Dockerイメージに'latest'以外のタグを付け、そのタグを使用してイメージをプルしてください。イメージのバージョンを指定しなければ`Always`のプルイメージポリシーにより`:latest`と仮定され、もしデフォルトのDockerレジストリ(通常はDockerHub)にどのバージョンのDockerイメージもまだ存在しない場合には、`ErrImagePull`になる恐れがあります。
+{{< /note >}}
 
-```shell
-eval $(minikube docker-env)
-```
+Mac/LinuxのホストでDockerデーモンを操作できるようにするには、`minikube docker-env`を実行します。
 
-これにより、MinikubeのVM内のDockerデーモンと通信しているホストのMac/LinuxマシンのコマンドラインでDockerを使用できるようになっているはずです。
+これにより、MinikubeのVM内のDockerデーモンと通信しているホストのMac/LinuxマシンのコマンドラインでDockerを使用できるようになります:
 
 ```shell
 docker ps
 ```
 
+{{< note >}}
 CentOS 7では、Dockerが以下のエラーを出力することがあります:
 
-```shell
+```
 Could not read CA certificate "/etc/docker/ca.pem": open /etc/docker/ca.pem: no such file or directory
 ```
 
-修正方法としては、/etc/sysconfig/docker を更新してMinikube環境の変更が確実に反映されるようにすることです:
+修正方法としては、/etc/sysconfig/dockerを更新してMinikube環境の変更が確実に反映されるようにすることです:
 
 ```shell
 < DOCKER_CERT_PATH=/etc/docker
@@ -233,37 +332,7 @@ Could not read CA certificate "/etc/docker/ca.pem": open /etc/docker/ca.pem: no
 >   DOCKER_CERT_PATH=/etc/docker
 > fi
 ```
-
-imagePullPolicy:Alwaysをオフにすることを忘れないでください: さもなければKubernetesはローカルに構築したイメージを使用しません。
-
-## クラスターの管理
-
-### クラスターの起動
-
-`minikube start` コマンドはクラスターを起動することができます。
-このコマンドはシングルノードのKubernetesクラスターを実行する仮想マシンを作成・設定します。
-また、このクラスターと通信する [kubectl](/docs/user-guide/kubectl-overview/) のインストールも設定します。
-
-もしWebプロキシーを通している場合、そのプロキシー情報を `minikube start` コマンドに渡す必要があります:
-
-```shell
-https_proxy=<my proxy> minikube start --docker-env http_proxy=<my proxy> --docker-env https_proxy=<my proxy> --docker-env no_proxy=192.168.99.0/24
-```
-
-残念なことに、ただ環境変数を設定するだけではうまく動作しません。
-
-Minikubeは "minikube" コンテキストも作成し、そのコンテキストをデフォルト設定としてkubectlに設定します。
-あとでコンテキストを切り戻すには、このコマンドを実行してください: `kubectl config use-context minikube`
-
-#### Kubernetesバージョンの指定
-
-`minikube start` コマンドに `--kubernetes-version` 文字列を追加することで、
-MinikubeにKubernetesの特定のバージョンを指定することができます。
-例えば、`v1.7.3` のバージョンを実行するには以下を実行します:
-
-```
-minikube start --kubernetes-version v1.7.3
-```
+{{< /note >}}
 
 ### Kubernetesの設定
 
@@ -293,16 +362,19 @@ Kubeletの `MaxPods` 設定を5に変更するには、このフラグを渡し
 
 `apiserver` の `AuthorizationMode` を `RABC` に設定するには、このフラグを使います: `--extra-config=apiserver.authorization-mode=RBAC`.
 
-### クラスターの停止
+### クラスターの停止 {#stopping-a-cluster}
 `minikube stop` コマンドを使ってクラスターを停止することができます。
 このコマンドはMinikube仮想マシンをシャットダウンしますが、すべてのクラスターの状態とデータを保存します。
 クラスターを再起動すると、以前の状態に復元されます。
 
-### クラスターの削除
+### クラスターの削除 {#deleting-a-cluster}
 `minikube delete` コマンドを使ってクラスターを削除することができます。
 このコマンドはMinikube仮想マシンをシャットダウンして削除します。データや状態は保存されません。
 
-## クラスターに触れてみよう
+### minikubeのアップグレード {#upgrading-minikube}
+[minikubeのアップグレード](https://minikube.sigs.k8s.io/docs/start/macos/)を参照してください。
+
+## クラスターに触れてみよう {#interacting-with-your-cluster}
 
 ### Kubectl
 
@@ -379,7 +451,7 @@ spec:
 | VirtualBox | Linux | /home | /hosthome |
 | VirtualBox | macOS | /Users | /Users |
 | VirtualBox | Windows | C://Users | /c/Users |
-| VMware Fusion | macOS | /Users | /Users |
+| VMware Fusion | macOS | /Users | /mnt/hgfs/Users |
 | Xhyve | macOS | /Users | /Users |
 
 ## プライベートコンテナレジストリ
@@ -417,10 +489,8 @@ export no_proxy=$no_proxy,$(minikube ip)
 ```
 
 ## 既知の問題
-* クラウドプロバイダーを必要とする機能はMinikubeでは動作しません
-  * ロードバランサー
-* 複数ノードを必要とする機能
-  * 高度なスケジューリングポリシー
+
+複数ノードを必要とする機能はMinikubeでは動作しません。
 
 ## 設計
 
@@ -440,5 +510,3 @@ Minikubeの詳細については、[proposal](https://git.k8s.io/community/contr
 ## コミュニティ
 
 コントリビューションや質問、コメントは歓迎・奨励されています! Minikubeの開発者は[Slack](https://kubernetes.slack.com)の#minikubeチャンネルにいます(Slackへの招待状は[こちら](http://slack.kubernetes.io/))。[kubernetes-dev Google Groupsメーリングリスト](https://groups.google.com/forum/#!forum/kubernetes-dev)もあります。メーリングリストに投稿する際は件名の最初に "minikube: " をつけてください。
-
-
diff --git a/content/ja/docs/setup/production-environment/tools/kops.md b/content/ja/docs/setup/production-environment/tools/kops.md
index e0203ca097..92899a300a 100644
--- a/content/ja/docs/setup/production-environment/tools/kops.md
+++ b/content/ja/docs/setup/production-environment/tools/kops.md
@@ -1,6 +1,6 @@
 ---
 title: kopsを使ったAWS上でのKubernetesのインストール
-content_type: concept
+content_type: task
 weight: 20
 ---
 
@@ -9,35 +9,40 @@ weight: 20
 This quickstart shows you how to easily install a Kubernetes cluster on AWS.
 It uses a tool called [`kops`](https://github.com/kubernetes/kops).
 
-kops is an opinionated provisioning system:
+kops is an automated provisioning system:
 
 * Fully automated installation
 * Uses DNS to identify clusters
 * Self-healing: everything runs in Auto-Scaling Groups
-* Multiple OS support (Debian, Ubuntu 16.04 supported, CentOS & RHEL, Amazon Linux and CoreOS) - see the [images.md](https://github.com/kubernetes/kops/blob/master/docs/images.md)
-* High-Availability support - see the [high_availability.md](https://github.com/kubernetes/kops/blob/master/docs/high_availability.md)
+* Multiple OS support (Debian, Ubuntu 16.04 supported, CentOS & RHEL, Amazon Linux and CoreOS) - see the [images.md](https://github.com/kubernetes/kops/blob/master/docs/operations/images.md)
+* High-Availability support - see the [high_availability.md](https://github.com/kubernetes/kops/blob/master/docs/operations/high_availability.md)
 * Can directly provision, or generate terraform manifests - see the [terraform.md](https://github.com/kubernetes/kops/blob/master/docs/terraform.md)
 
-If your opinions differ from these you may prefer to build your own cluster using [kubeadm](/docs/admin/kubeadm/) as
-a building block.  kops builds on the kubeadm work.
+
+
+## {{% heading "prerequisites" %}}
+
+
+* You must have [kubectl](/docs/tasks/tools/install-kubectl/) installed.
+
+* You must [install](https://github.com/kubernetes/kops#installing) `kops` on a 64-bit (AMD64 and Intel 64) device architecture.
+
+* You must have an [AWS account](https://docs.aws.amazon.com/polly/latest/dg/setting-up.html), generate [IAM keys](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys) and [configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration) them.
 
 
 
-<!-- body -->
+<!-- steps -->
 
 ## クラスタの作成
 
 ### (1/5) kopsのインストール
 
-#### 要件
-
-You must have [kubectl](/ja/docs/tasks/tools/install-kubectl/) installed in order for kops to work.
-
 #### インストール
 
 Download kops from the [releases page](https://github.com/kubernetes/kops/releases) (it is also easy to build from source):
 
-On macOS:
+{{< tabs name="kops_installation" >}}
+{{% tab name="macOS" %}}
 
 Download the latest release with the command:
 
@@ -45,14 +50,12 @@ Download the latest release with the command:
 curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-darwin-amd64
 ```
 
-To download a specific version, replace the
+To download a specific version, replace the following portion of the command with the specific kops version.
 
 ```shell
 $(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)
 ```
 
-portion of the command with the specific version.
-
 For example, to download kops version v1.15.0 type:
 
 ```shell
@@ -76,8 +79,8 @@ You can also install kops using [Homebrew](https://brew.sh/).
 ```shell
 brew update && brew install kops
 ```
-
-On Linux:
+{{% /tab %}}
+{{% tab name="Linux" %}}
 
 Download the latest release with the command:
 
@@ -85,11 +88,11 @@ Download the latest release with the command:
 curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64
 ```
 
-To download a specific version, replace the
+To download a specific version of kops, replace the following portion of the command with the specific kops version.
+
 ```shell
 $(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)
 ```
-portion of the command with the specific version.
 
 For example, to download kops version v1.15.0 type:
 
@@ -115,9 +118,13 @@ You can also install kops using [Homebrew](https://docs.brew.sh/Homebrew-on-Linu
 brew update && brew install kops
 ```
 
+{{% /tab %}}
+{{< /tabs >}}
+
+
 ### (2/5) クラスタ用のroute53ドメインの作成
 
-kops uses DNS for discovery, both inside the cluster and so that you can reach the kubernetes API server
+kops uses DNS for discovery, both inside the cluster and outside, so that you can reach the kubernetes API server
 from clients.
 
 kops has a strong opinion on the cluster name: it should be a valid DNS name.  By doing so you will
@@ -174,7 +181,7 @@ the S3 bucket name.
 
 ### (4/5) クラスタ設定の構築
 
-Run "kops create cluster" to create your cluster configuration:
+Run `kops create cluster` to create your cluster configuration:
 
 `kops create cluster --zones=us-east-1c useast1.dev.example.com`
 
@@ -213,24 +220,20 @@ for production clusters!
 
 ### 他のアドオンの参照
 
-See the [list of add-ons](/docs/concepts/cluster-administration/addons/) to explore other add-ons, including tools for logging, monitoring, network policy, visualization &amp; control of your Kubernetes cluster.
+See the [list of add-ons](/docs/concepts/cluster-administration/addons/) to explore other add-ons, including tools for logging, monitoring, network policy, visualization, and control of your Kubernetes cluster.
 
 ## クリーンアップ
 
 * To delete your cluster: `kops delete cluster useast1.dev.example.com --yes`
 
-## フィードバック
-
-* Slack Channel: [#kops-users](https://kubernetes.slack.com/messages/kops-users/)
-* [GitHub Issues](https://github.com/kubernetes/kops/issues)
-
 
 
 ## {{% heading "whatsnext" %}}
 
 
 * Learn more about Kubernetes [concepts](/docs/concepts/) and [`kubectl`](/docs/user-guide/kubectl-overview/).
-* Learn about `kops` [advanced usage](https://github.com/kubernetes/kops)
-* See the `kops` [docs](https://github.com/kubernetes/kops) section for tutorials, best practices and advanced configuration options.
+* Learn more about `kops` [advanced usage](https://kops.sigs.k8s.io/) for tutorials, best practices and advanced configuration options.
+* Follow `kops` community discussions on Slack: [community discussions](https://github.com/kubernetes/kops#other-ways-to-communicate-with-the-contributors)
+* Contribute to `kops` by addressing or raising an issue [GitHub Issues](https://github.com/kubernetes/kops/issues)
 
 
diff --git a/content/ja/docs/setup/production-environment/tools/kubeadm/high-availability.md b/content/ja/docs/setup/production-environment/tools/kubeadm/high-availability.md
index b9e82a7838..6b7cb8b610 100644
--- a/content/ja/docs/setup/production-environment/tools/kubeadm/high-availability.md
+++ b/content/ja/docs/setup/production-environment/tools/kubeadm/high-availability.md
@@ -8,16 +8,14 @@ weight: 60
 
 このページでは、kubeadmを使用して、高可用性クラスターを作成する、2つの異なるアプローチを説明します:
 
-- 積み重なったコントロールプレーンノードを使う方法。こちらのアプローチは、必要なインフラストラクチャーが少ないです。etcdのメンバーと、コントロールプレーンノードは同じ場所に置かれます。
+- 積層コントロールプレーンノードを使う方法。こちらのアプローチは、必要なインフラストラクチャーが少ないです。etcdのメンバーと、コントロールプレーンノードは同じ場所に置かれます。
 - 外部のetcdクラスターを使う方法。こちらのアプローチには、より多くのインフラストラクチャーが必要です。コントロールプレーンノードと、etcdのメンバーは分離されます。
 
-先へ進む前に、どちらのアプローチがアプリケーションの要件と、環境に適合するか、慎重に検討してください。[こちらの比較](/ja/docs/setup/independent/ha-topology/)が、それぞれの利点/欠点について概説しています。
+先へ進む前に、どちらのアプローチがアプリケーションの要件と、環境に適合するか、慎重に検討してください。[こちらの比較](/ja/docs/setup/production-environment/tools/kubeadm/ha-topology/)が、それぞれの利点/欠点について概説しています。
 
-クラスターではKubernetesのバージョン1.12以降を使用する必要があります。また、kubeadmを使用した高可用性クラスターはまだ実験的な段階であり、将来のバージョンではもっとシンプルになることに注意してください。たとえば、クラスターのアップグレードに際し問題に遭遇するかもしれません。両方のアプローチを試し、kueadmの[issue tracker](https://github.com/kubernetes/kubeadm/issues/new)で我々にフィードバックを提供してくれることを推奨します。
+高可用性クラスターの作成で問題が発生した場合は、kueadmの[issue tracker](https://github.com/kubernetes/kubeadm/issues/new)でフィードバックを提供してください。
 
-alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.13で削除されたことに留意してください。
-
-[高可用性クラスターのアップグレード](/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade-ha-1-13)も参照してください。
+[高可用性クラスターのアップグレード](/docs/tasks/administer-cluster/kubeadm/kubeadm-upgrade/)も参照してください。
 
 {{< caution >}}
 このページはクラウド上でクラスターを構築することには対応していません。ここで説明されているどちらのアプローチも、クラウド上で、LoadBalancerタイプのServiceオブジェクトや、動的なPersistentVolumeを利用して動かすことはできません。
@@ -30,8 +28,8 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
 
 どちらの方法でも、以下のインフラストラクチャーが必要です:
 
-- master用に、[kubeadmの最小要件](/ja/docs/setup/independent/install-kubeadm/#before-you-begin)を満たす3台のマシン
-- worker用に、[kubeadmの最小要件](/ja/docs/setup/independent/install-kubeadm/#before-you-begin)を満たす3台のマシン
+- master用に、[kubeadmの最小要件](/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#始める前に)を満たす3台のマシン
+- worker用に、[kubeadmの最小要件](/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#始める前に)を満たす3台のマシン
 - クラスター内のすべてのマシン間がフルにネットワーク接続可能であること(パブリック、もしくはプライベートネットワーク)
 - すべてのマシンにおいて、sudo権限
 - あるデバイスから、システム内のすべてのノードに対しSSH接続できること
@@ -41,22 +39,11 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
 
 - etcdメンバー用に、追加で3台のマシン
 
-{{< note >}}
-以下の例では、CalicoをPodネットワーキングプロバイダーとして使用します。別のネットワーキングプロバイダーを使用する場合、必要に応じてデフォルトの値を変更してください。
-{{< /note >}}
-
-
 
 <!-- steps -->
 
 ## 両手順における最初のステップ
 
-{{< note >}}
-コントロールプレーンや、etcdノードでのコマンドはすべてrootとして実行してください。
-{{< /note >}}
-
-- CalicoなどのいくつかのCNIネットワークプラグインは`192.168.0.0/16`のようなCIDRを必要としますが、Weaveなどは必要としません。[CNIネットワークドキュメント](/ja/docs/setup/independent/create-cluster-kubeadm/#pod-network)を参照してください。PodにCIDRを設定するには、`ClusterConfiguration`の`networking`オブジェクトに`podSubnet: 192.168.0.0/16`フィールドを設定してください。
-
 ### kube-apiserver用にロードバランサーを作成
 
 {{< note >}}
@@ -84,7 +71,181 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
 
 1.  残りのコントロールプレーンノードを、ロードバランサーのターゲットグループに追加します。
 
-### SSHの設定
+## 積層コントロールプレーンとetcdノード
+
+### 最初のコントロールプレーンノードの手順
+
+1.  最初のコントロールプレーンノードを初期化します:
+
+    ```sh
+    sudo kubeadm init --control-plane-endpoint "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT" --upload-certs
+    ```
+
+    - `--kubernetes-version`フラグで使用するKubernetesのバージョンを設定できます。kubeadm、kubelet、kubectl、Kubernetesのバージョンを一致させることが推奨されます。
+    - `--control-plane-endpoint`フラグは、ロードバランサーのIPアドレスまたはDNS名と、ポートが設定される必要があります。
+    - `--upload-certs`フラグは全てのコントロールプレーンノードで共有する必要がある証明書をクラスターにアップロードするために使用されます。代わりに、コントロールプレーンノード間で手動あるいは自動化ツールを使用して証明書をコピーしたい場合は、このフラグを削除し、以下の[証明書の手動配布](#manual-certs)のセクションを参照してください。
+
+    {{< note >}}`kubeadm init`の`--config`フラグと`--certificate-key`フラグは混在させることはできないため、[kubeadm configuration](https://godoc.org/k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2)を使用する場合は`certificateKey`フィールドを適切な場所に追加する必要があります(`InitConfiguration`と`JoinConfiguration: controlPlane`の配下)。{{< /note >}}
+
+    {{< note >}}CalicoなどのいくつかのCNIネットワークプラグインは`192.168.0.0/16`のようなCIDRを必要としますが、Weaveなどは必要としません。[CNIネットワークドキュメント](/ja/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#pod-network)を参照してください。PodにCIDRを設定するには、`ClusterConfiguration`の`networking`オブジェクトに`podSubnet: 192.168.0.0/16`フィールドを設定してください。{{< /note >}}
+
+    - このような出力がされます:
+
+    ```sh
+    ...
+    You can now join any number of control-plane node by running the following command on each as a root:
+        kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866 --control-plane --certificate-key f8902e114ef118304e561c3ecd4d0b543adc226b7a07f675f56564185ffe0c07
+    
+    Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
+    As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use kubeadm init phase upload-certs to reload certs afterward.
+    
+    Then you can join any number of worker nodes by running the following on each as root:
+        kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866
+    ```
+
+    - この出力をテキストファイルにコピーします。あとで、他のコントロールプレーンノードとワーカーノードをクラスターに参加させる際に必要です。
+
+    - `--upload-certs`フラグを`kubeadm init`で使用すると、プライマリコントロールプレーンの証明書が暗号化されて、`kubeadm-certs` Secretにアップロードされます。
+
+    - 証明書を再アップロードして新しい復号キーを生成するには、すでにクラスターに参加しているコントロールプレーンノードで次のコマンドを使用します:
+
+    ```sh
+    sudo kubeadm init phase upload-certs --upload-certs
+    ```
+
+    - また、後で`join`で使用できるように、`init`中にカスタムした`--certificate-key`を指定することもできます。このようなキーを生成するには、次のコマンドを使用します:
+
+    ```sh
+    kubeadm alpha certs certificate-key
+    ```
+
+    {{< note >}}
+    `kubeadm-certs`のSecretと復号キーは2時間で期限切れとなります。
+    {{< /note >}}
+
+    {{< caution >}}
+    コマンド出力に記載されているように、証明書キーはクラスターの機密データへのアクセスを提供します。秘密にしてください！
+    {{< /caution >}}
+
+1.  使用するCNIプラグインを適用します:  
+    [こちらの手順に従い](/ja/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/#pod-network)CNIプロバイダーをインストールします。該当する場合は、kubeadmの設定で指定されたPodのCIDRに対応していることを確認してください。
+
+    Weave Netを使用する場合の例:
+
+    ```sh
+    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
+    ```
+
+1.  以下のコマンドを入力し、コンポーネントのPodが起動するのを確認します:
+
+    ```sh
+    kubectl get pod -n kube-system -w
+    ```
+
+### 残りのコントロールプレーンノードの手順
+
+{{< note >}}
+kubeadmバージョン1.15以降、複数のコントロールプレーンノードを並行してクラスターに参加させることができます。
+このバージョンの前は、最初のノードの初期化が完了した後でのみ、新しいコントロールプレーンノードを順番にクラスターに参加させる必要があります。
+{{< /note >}}
+
+追加のコントロールプレーンノード毎に、以下の手順を行います。
+
+1.  `kubeadm init`を最初のノードで実行した際に取得したjoinコマンドを使って、新しく追加するコントロールプレーンノードで`kubeadm join`を開始します。このようなコマンドになるはずです:
+
+    ```sh
+    sudo kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866 --control-plane --certificate-key f8902e114ef118304e561c3ecd4d0b543adc226b7a07f675f56564185ffe0c07
+    ```
+
+    - `--control-plane`フラグによって、`kubeadm join`の実行は新しいコントロールプレーンを作成します。
+    - `-certificate-key ...`を指定したキーを使って、クラスターの`kubeadm-certs` Secretからダウンロードされたコントロールプレーンの証明書が復号されます。
+
+## 外部のetcdノード
+
+外部のetcdノードを使ったクラスターの設定は、積層etcdの場合と似ていますが、最初にetcdを設定し、kubeadmの設定ファイルにetcdの情報を渡す必要があります。
+
+### etcdクラスターの構築
+
+1. [こちらの手順](/ja/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm/)にしたがって、etcdクラスターを構築してください。
+
+1. [こちらの手順](#manual-certs)にしたがって、SSHを構築してください。
+
+1. 以下のファイルをクラスター内の任意のetcdノードから最初のコントロールプレーンノードにコピーしてください:
+
+    ```sh
+    export CONTROL_PLANE="ubuntu@10.0.0.7"
+    scp /etc/kubernetes/pki/etcd/ca.crt "${CONTROL_PLANE}":
+    scp /etc/kubernetes/pki/apiserver-etcd-client.crt "${CONTROL_PLANE}":
+    scp /etc/kubernetes/pki/apiserver-etcd-client.key "${CONTROL_PLANE}":
+    ```
+
+    - `CONTROL_PLANE`の値を、最初のコントロールプレーンノードの`user@host`で置き換えます。
+
+### 最初のコントロールプレーンノードの構築
+
+1.  以下の内容で、`kubeadm-config.yaml`という名前の設定ファイルを作成します:
+
+        apiVersion: kubeadm.k8s.io/v1beta2
+        kind: ClusterConfiguration
+        kubernetesVersion: stable
+        controlPlaneEndpoint: "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT"
+        etcd:
+            external:
+                endpoints:
+                - https://ETCD_0_IP:2379
+                - https://ETCD_1_IP:2379
+                - https://ETCD_2_IP:2379
+                caFile: /etc/kubernetes/pki/etcd/ca.crt
+                certFile: /etc/kubernetes/pki/apiserver-etcd-client.crt
+                keyFile: /etc/kubernetes/pki/apiserver-etcd-client.key
+
+    {{< note >}}
+    ここで、積層etcdと外部etcdの違いは、外部etcdの構成では`etcd`の`external`オブジェクトにetcdのエンドポイントが記述された設定ファイルが必要です。積層etcdトポロジーの場合、これは自動で管理されます。
+    {{< /note >}}
+
+    -  テンプレート内の以下の変数を、クラスターに合わせて適切な値に置き換えます:
+
+        - `LOAD_BALANCER_DNS`
+        - `LOAD_BALANCER_PORT`
+        - `ETCD_0_IP`
+        - `ETCD_1_IP`
+        - `ETCD_2_IP`
+
+以下の手順は、積層etcdの構築と同様です。
+
+1.  `sudo kubeadm init --config kubeadm-config.yaml --upload-certs`をこのノードで実行します。
+
+1.  表示されたjoinコマンドを、あとで使うためにテキストファイルに書き込みます。
+
+1.  使用するCNIプラグインを適用します。以下はWeave CNIの場合です:
+
+    ```sh
+    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
+    ```
+
+### 残りのコントロールプレーンノードの手順
+
+手順は、積層etcd構築の場合と同じです:
+
+- 最初のコントロールプレーンノードが完全に初期化されているのを確認します。
+- テキストファイルに保存したjoinコマンドを使って、それぞれのコントロールプレーンノードをクラスターへ参加させます。コントロールプレーンノードは1台ずつクラスターへ参加させるのを推奨します。
+- `--certificate-key`で指定する復号キーは、デフォルトで2時間で期限切れになることを忘れないでください。
+
+## コントロールプレーン起動後の共通タスク
+
+### workerのインストール
+
+`kubeadm init`コマンドから返されたコマンドを利用して、workerノードをクラスターに参加させることが可能です。
+
+```sh
+sudo kubeadm join 192.168.0.200:6443 --token 9vr73a.a8uxyaju799qwdjv --discovery-token-ca-cert-hash sha256:7c2e69131a36ae2a042a339b33381c6d0d43887e2de83720eff5359e26aec866
+```
+
+## 証明書の手動配布 {#manual-certs}
+
+`--upload-certs`フラグを指定して`kubeadm init`を実行しない場合、プライマリコントロールプレーンノードから他のコントロールプレーンノードへ証明書を手動でコピーする必要があります。
+
+コピーを行うには多くの方法があります。次の例では`ssh`と`scp`を使用しています。
 
 1台のマシンから全てのノードをコントロールしたいのであれば、SSHが必要です。
 
@@ -114,61 +275,12 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
         sudo -E -s
         ```
 
-## 積み重なったコントロールプレーンとetcdノード
+1.  全てのノードでSSHを設定したら、`kubeadm init`を実行した後、最初のコントロールノードプレーンノードで次のスクリプトを実行します。このスクリプトは、最初のコントロールプレーンノードから残りのコントロールプレーンノードへ証明書ファイルをコピーします:
 
-### 最初のコントロールプレーンノードの手順
-
-1.  最初のコントロールプレーンノードで、`kubeadm-config.yaml`という設定ファイルを作成します:
-
-        apiVersion: kubeadm.k8s.io/v1beta1
-        kind: ClusterConfiguration
-        kubernetesVersion: stable
-        apiServer:
-          certSANs:
-          - "LOAD_BALANCER_DNS"
-        controlPlaneEndpoint: "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT"
-
-    - `kubernetesVersion`には使用するKubernetesのバージョンを設定します。この例では`stable`を使用しています。
-    - `controlPlaneEndpoint` はロードバランサーのアドレスかDNSと、ポートに一致する必要があります。
-    - kubeadm、kubelet、kubectlとKubernetesのバージョンを一致させることが推奨されます。
-
-1.  ノードがきれいな状態であることを確認します:
+    次の例の、`CONTROL_PLANE_IPS`を他のコントロールプレーンノードのIPアドレスに置き換えます。
 
     ```sh
-    sudo kubeadm init --config=kubeadm-config.yaml
-    ```
-
-    このような出力がされます:
-
-    ```sh
-    ...
-    You can now join any number of machines by running the following on each node
-    as root:
-
-    kubeadm join 192.168.0.200:6443 --token j04n3m.octy8zely83cy2ts --discovery-token-ca-cert-hash    sha256:84938d2a22203a8e56a787ec0c6ddad7bc7dbd52ebabc62fd5f4dbea72b14d1f
-    ```
-
-1.  この出力をテキストファイルにコピーします。あとで、他のコントロールプレーンノードをクラスターに参加させる際に必要になります。
-
-1.  Weave CNIプラグインをapplyします:
-
-    ```sh
-    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
-    ```
-
-1.  以下のコマンドを入力し、コンポーネントのPodが起動するのを確認します:
-
-    ```sh
-    kubectl get pod -n kube-system -w
-    ```
-
-    - 最初のコントロールプレーンノードが初期化を完了してから、新しいノードを参加させることが推奨されます。
-
-1.  証明書ファイルを最初のコントロールプレーンノードから残りのノードにコピーします:
-
-    以下の例では、`CONTROL_PLANE_IPS`を他のコントロールプレーンノードのIPアドレスで置き換えます。
-    ```sh
-    USER=ubuntu # 変更可能
+    USER=ubuntu # 環境に合わせる
     CONTROL_PLANE_IPS="10.0.0.7 10.0.0.8"
     for host in ${CONTROL_PLANE_IPS}; do
         scp /etc/kubernetes/pki/ca.crt "${USER}"@$host:
@@ -178,21 +290,19 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
         scp /etc/kubernetes/pki/front-proxy-ca.crt "${USER}"@$host:
         scp /etc/kubernetes/pki/front-proxy-ca.key "${USER}"@$host:
         scp /etc/kubernetes/pki/etcd/ca.crt "${USER}"@$host:etcd-ca.crt
+        # 外部のetcdノード使用時はこちらのコマンドを実行
         scp /etc/kubernetes/pki/etcd/ca.key "${USER}"@$host:etcd-ca.key
-        scp /etc/kubernetes/admin.conf "${USER}"@$host:
     done
     ```
 
-{{< caution >}}
-上のリストにある証明書だけをコピーしてください。kubeadmが、参加するコントロールプレーンノード用に、残りの証明書と必要なSANの生成を行います。間違って全ての証明書をコピーしてしまったら、必要なSANがないため、追加ノードの作成は失敗するかもしれません。
-{{< /caution >}}
+    {{< caution >}}
+    上のリストにある証明書だけをコピーしてください。kubeadmが、参加するコントロールプレーンノード用に、残りの証明書と必要なSANの生成を行います。間違って全ての証明書をコピーしてしまったら、必要なSANがないため、追加ノードの作成は失敗するかもしれません。
+    {{< /caution >}}
 
-### 残りのコントロールプレーンノードの手順
-
-1.  `scp`を使用する手順で作成したファイルを移動します:
+1.  次に、クラスターに参加させる残りの各コントロールプレーンノードで`kubeadm join`を実行する前に次のスクリプトを実行する必要があります。このスクリプトは、前の手順でコピーした証明書をホームディレクトリから`/etc/kubernetes/pki`へ移動します:
 
     ```sh
-    USER=ubuntu # 変更可能
+    USER=ubuntu # 環境に合わせる
     mkdir -p /etc/kubernetes/pki/etcd
     mv /home/${USER}/ca.crt /etc/kubernetes/pki/
     mv /home/${USER}/ca.key /etc/kubernetes/pki/
@@ -201,103 +311,6 @@ alpha feature gateである`HighAvailability`はv1.12で非推奨となり、v1.
     mv /home/${USER}/front-proxy-ca.crt /etc/kubernetes/pki/
     mv /home/${USER}/front-proxy-ca.key /etc/kubernetes/pki/
     mv /home/${USER}/etcd-ca.crt /etc/kubernetes/pki/etcd/ca.crt
+    # 外部のetcdノード使用時はこちらのコマンドを実行
     mv /home/${USER}/etcd-ca.key /etc/kubernetes/pki/etcd/ca.key
-    mv /home/${USER}/admin.conf /etc/kubernetes/admin.conf
     ```
-
-    この手順で、`/etc/kubernetes`フォルダーに必要な全てのファイルが書き込まれます。
-
-1.  `kubeadm init`を最初のノードで実行した際に取得したjoinコマンドを使って、このノードで`kubeadm join`を開始します。このようなコマンドになるはずです:
-
-    ```sh
-    sudo kubeadm join 192.168.0.200:6443 --token j04n3m.octy8zely83cy2ts --discovery-token-ca-cert-hash sha256:84938d2a22203a8e56a787ec0c6ddad7bc7dbd52ebabc62fd5f4dbea72b14d1f --experimental-control-plane
-    ```
-    - `--experimental-control-plane`フラグが追加されています。このフラグは、コントロールプレーンノードのクラスターへの参加を自動化します。
-
-1.  以下のコマンドをタイプし、コンポーネントのPodが起動するのを確認します:
-
-    ```sh
-    kubectl get pod -n kube-system -w
-    ```
-
-1.  これらのステップを、残りのコントロールプレーンノードに対して繰り返します。
-
-## 外部のetcdノード
-
-### etcdクラスターの構築
-
-- [こちらの手順](/ja/docs/setup/independent/setup-ha-etcd-with-kubeadm/)にしたがって、etcdクラスターを構築してください。
-
-### 最初のコントロールプレーンノードの構築
-
-1.  以下のファイルをetcdクラスターのどれかのノードからこのノードへコピーしてください:
-
-    ```sh
-    export CONTROL_PLANE="ubuntu@10.0.0.7"
-    +scp /etc/kubernetes/pki/etcd/ca.crt "${CONTROL_PLANE}":
-    +scp /etc/kubernetes/pki/apiserver-etcd-client.crt "${CONTROL_PLANE}":
-    +scp /etc/kubernetes/pki/apiserver-etcd-client.key "${CONTROL_PLANE}":
-    ```
-
-    - `CONTROL_PLANE`の値を、このマシンの`user@host`で置き換えます。
-
-1.  以下の内容で、`kubeadm-config.yaml`という名前の設定ファイルを作成します:
-
-        apiVersion: kubeadm.k8s.io/v1beta1
-        kind: ClusterConfiguration
-        kubernetesVersion: stable
-        apiServer:
-          certSANs:
-          - "LOAD_BALANCER_DNS"
-        controlPlaneEndpoint: "LOAD_BALANCER_DNS:LOAD_BALANCER_PORT"
-        etcd:
-            external:
-                endpoints:
-                - https://ETCD_0_IP:2379
-                - https://ETCD_1_IP:2379
-                - https://ETCD_2_IP:2379
-                caFile: /etc/kubernetes/pki/etcd/ca.crt
-                certFile: /etc/kubernetes/pki/apiserver-etcd-client.crt
-                keyFile: /etc/kubernetes/pki/apiserver-etcd-client.key
-
-    - ここで、積み重なったetcdと外部etcdの違いは、kubeadmコンフィグの`etcd`に`external`フィールドを使用していることです。積み重なったetcdトポロジーの場合、これは自動で管理されます。
-
-    -  テンプレート内の以下の変数を、クラスターに合わせて適切な値に置き換えます:
-
-        - `LOAD_BALANCER_DNS`
-        - `LOAD_BALANCER_PORT`
-        - `ETCD_0_IP`
-        - `ETCD_1_IP`
-        - `ETCD_2_IP`
-
-1.  `kubeadm init --config kubeadm-config.yaml`をこのノードで実行します。
-
-1.  表示されたjoinコマンドを、あとで使うためにテキストファイルに書き込みます。
-
-1.  Weave CNIプラグインをapplyします:
-
-    ```sh
-    kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
-    ```
-
-### 残りのコントロールプレーンノードの手順
-
-残りのコントロールプレーンノードを参加させるために、[こちらの手順](#残りのコントロールプレーンノードの手順)に従います。ローカルetcdメンバーが作られないことを除いて、積み重なったetcdの構築と同じ手順です。
-
-まとめると:
-
-- 最初のコントロールプレーンノードが完全に初期化されているのを確認します。
-- 証明書を、最初のコントロールプレーンノードから他のコントロールプレーンノードへコピーします。
-- テキストファイルに保存したjoinコマンドに`--experimental-control-plane` フラグを加えたものを使って、それぞれのコントロールプレーンノードを参加させます。
-
-## コントロールプレーン起動後の共通タスク
-
-### Podネットワークのインストール
-
-Podネットワークをインストールするには、[こちらの手順に従ってください](/ja/docs/setup/independent/create-cluster-kubeadm/#pod-network)。master設定ファイルで提供したPod CIDRのどれかに一致することを確認します。
-
-### workerのインストール
-
-`kubeadm init`コマンドから返されたコマンドを利用して、workerノードをクラスターに参加させることが可能です。workerノードには、`--experimental-control-plane`フラグを追加する必要はありません。
-
-
diff --git a/content/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md b/content/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md
index b03166af12..0a33f216f9 100644
--- a/content/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md
+++ b/content/ja/docs/setup/production-environment/tools/kubeadm/install-kubeadm.md
@@ -79,20 +79,20 @@ update-alternatives --set iptables /usr/sbin/iptables-legacy
 
 | プロトコル | 通信の向き | ポート範囲  | 目的                    | 使用者                    |
 |-----------|------------|------------|-------------------------|---------------------------|
-| TCP       | Inbound    | 6443*      | Kubernetes API server   | All                       |
-| TCP       | Inbound    | 2379-2380  | etcd server client API  | kube-apiserver, etcd      |
-| TCP       | Inbound    | 10250      | Kubelet API             | Self, Control plane       |
-| TCP       | Inbound    | 10251      | kube-scheduler          | Self                      |
-| TCP       | Inbound    | 10252      | kube-controller-manager | Self                      |
+| TCP       | Inbound    | 6443*      | Kubernetes API server   | 全て                      |
+| TCP       | Inbound    | 2379-2380  | etcd server client API  | kube-apiserver、etcd      |
+| TCP       | Inbound    | 10250      | Kubelet API             | 自身、コントロールプレーン |
+| TCP       | Inbound    | 10251      | kube-scheduler          | 自身                      |
+| TCP       | Inbound    | 10252      | kube-controller-manager | 自身                      |
 
 ### ワーカーノード
 
-| プロトコル | 通信の向き | ポート範囲   | 目的                    | 使用者                  |
-|-----------|------------|-------------|-------------------------|-------------------------|
-| TCP       | Inbound    | 10250       | Kubelet API             | Self, Control plane     |
-| TCP       | Inbound    | 30000-32767 | NodePort Services**     | All                     |
+| プロトコル | 通信の向き | ポート範囲   | 目的                    | 使用者                    |
+|-----------|------------|-------------|-------------------------|---------------------------|
+| TCP       | Inbound    | 10250       | Kubelet API             | 自身、コントロールプレーン |
+| TCP       | Inbound    | 30000-32767 | NodePort Service†     | 全て                      |
 
-** [NodePort Services](/ja/docs/concepts/services-networking/service/)のデフォルトのポートの範囲
+† [NodePort Service](/ja/docs/concepts/services-networking/service/)のデフォルトのポートの範囲
 
 \*の項目は書き換え可能です。そのため、あなたが指定したカスタムポートも開いていることを確認する必要があります。
 
@@ -106,7 +106,7 @@ v1.6.0以降、KubernetesはデフォルトでCRI(Container Runtime Interface)
 
 また、v1.14.0以降、kubeadmは既知のドメインソケットのリストをスキャンして、Linuxノード上のコンテナランタイムを自動的に検出しようとします。検出可能なランタイムとソケットパスは、以下の表に記載されています。
 
-| ランタイム  | ドメインソケット                   |
+| ランタイム  | ドメインソケット                  |
 |------------|----------------------------------|
 | Docker     | /var/run/docker.sock             |
 | containerd | /run/containerd/containerd.sock  |
diff --git a/content/ja/docs/setup/production-environment/tools/kubeadm/kubelet-integration.md b/content/ja/docs/setup/production-environment/tools/kubeadm/kubelet-integration.md
index edf95ce712..2e29dce165 100644
--- a/content/ja/docs/setup/production-environment/tools/kubeadm/kubelet-integration.md
+++ b/content/ja/docs/setup/production-environment/tools/kubeadm/kubelet-integration.md
@@ -8,21 +8,11 @@ weight: 80
 
 {{< feature-state for_k8s_version="1.11" state="stable" >}}
 
-The lifecycle of the kubeadm CLI tool is decoupled from the
-[kubelet](/docs/reference/command-line-tools-reference/kubelet), which is a daemon that runs
-on each node within the Kubernetes cluster. The kubeadm CLI tool is executed by the user when Kubernetes is
-initialized or upgraded, whereas the kubelet is always running in the background.
+kubeadm CLIツールのライフサイクルは、Kubernetesクラスター内の各ノード上で稼働するデーモンである[kubelet](/docs/reference/command-line-tools-reference/kubelet)から分離しています。kubeadm CLIツールはKubernetesを初期化またはアップグレードする際にユーザーによって実行されます。一方で、kubeletは常にバックグラウンドで稼働しています。
 
-Since the kubelet is a daemon, it needs to be maintained by some kind of a init
-system or service manager. When the kubelet is installed using DEBs or RPMs,
-systemd is configured to manage the kubelet. You can use a different service
-manager instead, but you need to configure it manually.
+kubeletはデーモンのため、何らかのinitシステムやサービスマネージャーで管理する必要があります。DEBパッケージやRPMパッケージからkubeletをインストールすると、systemdはkubeletを管理するように設定されます。代わりに別のサービスマネージャーを使用することもできますが、手動で設定する必要があります。
 
-Some kubelet configuration details need to be the same across all kubelets involved in the cluster, while
-other configuration aspects need to be set on a per-kubelet basis, to accommodate the different
-characteristics of a given machine, such as OS, storage, and networking. You can manage the configuration
-of your kubelets manually, but [kubeadm now provides a `KubeletConfiguration` API type for managing your
-kubelet configurations centrally](#configure-kubelets-using-kubeadm).
+いくつかのkubeletの設定は、クラスターに含まれる全てのkubeletで同一である必要があります。一方で、特定のマシンの異なる特性(OS、ストレージ、ネットワークなど)に対応するために、kubeletごとに設定が必要なものもあります。手動で設定を管理することも可能ですが、kubeadmは[一元的な設定管理](#configure-kubelets-using-kubeadm)のための`KubeletConfiguration`APIを提供しています。
 
 
 
@@ -30,29 +20,19 @@ kubelet configurations centrally](#configure-kubelets-using-kubeadm).
 
 ## Kubeletの設定パターン
 
-The following sections describe patterns to kubelet configuration that are simplified by
-using kubeadm, rather than managing the kubelet configuration for each Node manually.
+以下のセクションでは、kubeadmを使用したkubeletの設定パターンについて説明します。これは手動で各Nodeの設定を管理するよりも簡易に行うことができます。
 
-### 各kubeletにクラスターレベルの設定を配布
+### 各kubeletにクラスターレベルの設定を配布 {#propagating-cluster-level-configuration-to-each-kubelet}
 
-You can provide the kubelet with default values to be used by `kubeadm init` and `kubeadm join`
-commands. Interesting examples include using a different CRI runtime or setting the default subnet
-used by services.
+`kubeadm init`および`kubeadm join`コマンドを使用すると、kubeletにデフォルト値を設定することができます。興味深い例として、異なるCRIランタイムを使用したり、Serviceが使用するデフォルトのサブネットを設定したりすることができます。
 
-If you want your services to use the subnet `10.96.0.0/12` as the default for services, you can pass
-the `--service-cidr` parameter to kubeadm:
+Serviceが使用するデフォルトのサブネットとして`10.96.0.0/12`を設定する必要がある場合は、`--service-cidr`パラメーターを渡します。
 
 ```bash
 kubeadm init --service-cidr 10.96.0.0/12
 ```
 
-Virtual IPs for services are now allocated from this subnet. You also need to set the DNS address used
-by the kubelet, using the `--cluster-dns` flag. This setting needs to be the same for every kubelet
-on every manager and Node in the cluster. The kubelet provides a versioned, structured API object
-that can configure most parameters in the kubelet and push out this configuration to each running
-kubelet in the cluster. This object is called **the kubelet's ComponentConfig**.
-The ComponentConfig allows the user to specify flags such as the cluster DNS IP addresses expressed as
-a list of values to a camelCased key, illustrated by the following example:
+これによってServiceの仮想IPはこのサブネットから割り当てられるようになりました。また、`--cluster-dns`フラグを使用し、kubeletが用いるDNSアドレスを設定する必要もあります。この設定はクラスター内の全てのマネージャーとNode上で同一である必要があります。kubeletは、**kubeletのComponentConfig**と呼ばれる、バージョン管理と構造化されたAPIオブジェクトを提供します。これはkubelet内のほとんどのパラメーターを設定し、その設定をクラスター内で稼働中の各kubeletへ適用することを可能にします。以下の例のように、キャメルケースのキーに値のリストとしてクラスターDNS IPアドレスなどのフラグを指定することができます。
 
 ```yaml
 apiVersion: kubelet.config.k8s.io/v1beta1
@@ -61,109 +41,72 @@ clusterDNS:
 - 10.96.0.10
 ```
 
-For more details on the ComponentConfig have a look at [this section](#configure-kubelets-using-kubeadm).
+ComponentConfigの詳細については、[このセクション](#configure-kubelets-using-kubeadm)をご覧ください
 
-### インスタンス固有の設定内容を適用
+### インスタンス固有の設定内容を適用 {#providing-instance-specific-configuration-details}
 
-Some hosts require specific kubelet configurations, due to differences in hardware, operating system,
-networking, or other host-specific parameters. The following list provides a few examples.
+いくつかのホストでは、ハードウェア、オペレーティングシステム、ネットワーク、その他ホスト固有のパラメータの違いのため、特定のkubeletの設定を必要とします。以下にいくつかの例を示します。
 
-- The path to the DNS resolution file, as specified by the `--resolv-conf` kubelet
-  configuration flag, may differ among operating systems, or depending on whether you are using
-  `systemd-resolved`. If this path is wrong, DNS resolution will fail on the Node whose kubelet
-  is configured incorrectly.
+- DNS解決ファイルへのパスは`--resolv-conf`フラグで指定することができますが、オペレーティングシステムや`systemd-resolved`を使用するかどうかによって異なる場合があります。このパスに誤りがある場合、そのNode上でのDNS解決は失敗します。
+- クラウドプロバイダーを使用していない場合、Node APIオブジェクト`.metadata.name`はデフォルトでマシンのホスト名に設定されます。異なるNode名を指定する必要がある場合には、`--hostname-override`フラグによってこの挙動を書き換えることができます。
+- 現在のところ、kubletはCRIランタイムが使用するcgroupドライバを自動で検知することができませんが、kubeletの稼働を保証するためには、`--cgroup-driver`の値はCRIランタイムが使用するcgroupドライバに一致していなければなりません。
+- クラスターが使用するCRIランタイムによっては、異なるフラグを指定する必要があるかもしれません。例えば、Dockerを使用している場合には、`--network-plugin=cni`のようなフラグを指定する必要があります。外部のランタイムを使用している場合には、`--container-runtime=remote`と指定し、`--container-runtime-endpoint=<path>`のようにCRIエンドポイントを指定する必要があります。
 
-- The Node API object `.metadata.name` is set to the machine's hostname by default,
-  unless you are using a cloud provider. You can use the `--hostname-override` flag to override the
-  default behavior if you need to specify a Node name different from the machine's hostname.
+これらのフラグは、systemdなどのサービスマネージャー内のkubeletの設定によって指定することができます。
 
-- Currently, the kubelet cannot automatically detects the cgroup driver used by the CRI runtime,
-  but the value of `--cgroup-driver` must match the cgroup driver used by the CRI runtime to ensure
-  the health of the kubelet.
+## kubeadmを使用したkubeletの設定 {#configure-kubelets-using-kubeadm}
 
-- Depending on the CRI runtime your cluster uses, you may need to specify different flags to the kubelet.
-  For instance, when using Docker, you need to specify flags such as `--network-plugin=cni`, but if you
-  are using an external runtime, you need to specify `--container-runtime=remote` and specify the CRI
-  endpoint using the `--container-runtime-path-endpoint=<path>`.
+`kubeadm ... --config some-config-file.yaml`のように、カスタムの`KubeletConfiguration`APIオブジェクトを設定ファイルを介して渡すことで、kubeadmによって起動されるkubeletに設定を反映することができます。
 
-You can specify these flags by configuring an individual kubelet's configuration in your service manager,
-such as systemd.
+`kubeadm config print init-defaults --component-configs KubeletConfiguration`を実行することによって、この構造体の全てのデフォルト値を確認することができます。
 
-## kubeadmを使用したkubeletの設定
-
-It is possible to configure the kubelet that kubeadm will start if a custom `KubeletConfiguration`
-API object is passed with a configuration file like so `kubeadm ... --config some-config-file.yaml`.
-
-By calling `kubeadm config print init-defaults --component-configs KubeletConfiguration` you can
-see all the default values for this structure.
-
-Also have a look at the [API reference for the
-kubelet ComponentConfig](https://godoc.org/k8s.io/kubernetes/pkg/kubelet/apis/config#KubeletConfiguration)
-for more information on the individual fields.
+また、各フィールドの詳細については、[kubelet ComponentConfigに関するAPIリファレンス](https://godoc.org/k8s.io/kubernetes/pkg/kubelet/apis/config#KubeletConfiguration)を参照してください。
 
 ### `kubeadm init`実行時の流れ
 
-When you call `kubeadm init`, the kubelet configuration is marshalled to disk
-at `/var/lib/kubelet/config.yaml`, and also uploaded to a ConfigMap in the cluster. The ConfigMap
-is named `kubelet-config-1.X`, where `.X` is the minor version of the Kubernetes version you are
-initializing. A kubelet configuration file is also written to `/etc/kubernetes/kubelet.conf` with the
-baseline cluster-wide configuration for all kubelets in the cluster. This configuration file
-points to the client certificates that allow the kubelet to communicate with the API server. This
-addresses the need to
-[propagate cluster-level configuration to each kubelet](#propagating-cluster-level-configuration-to-each-kubelet).
+`kubeadm init`を実行した場合、kubeletの設定は`/var/lib/kubelet/config.yaml`に格納され、クラスターのConfigMapにもアップロードされます。ConfigMapは`kubelet-config-1.X`という名前で、`.X`は初期化するKubernetesのマイナーバージョンを表します。またこの設定ファイルは、クラスタ内の全てのkubeletのために、クラスター全体設定の基準と共に`/etc/kubernetes/kubelet.conf`にも書き込まれます。この設定ファイルは、kubeletがAPIサーバと通信するためのクライアント証明書を指し示します。これは、[各kubeletにクラスターレベルの設定を配布](#propagating-cluster-level-configuration-to-each-kubelet)することの必要性を示しています。
 
-To address the second pattern of
-[providing instance-specific configuration details](#providing-instance-specific-configuration-details),
-kubeadm writes an environment file to `/var/lib/kubelet/kubeadm-flags.env`, which contains a list of
-flags to pass to the kubelet when it starts. The flags are presented in the file like this:
+二つ目のパターンである、[インスタンス固有の設定内容を適用](#providing-instance-specific-configuration-details)するために、kubeadmは環境ファイルを`/var/lib/kubelet/kubeadm-flags.env`へ書き出します。このファイルは以下のように、kubelet起動時に渡されるフラグのリストを含んでいます。
 
 ```bash
 KUBELET_KUBEADM_ARGS="--flag1=value1 --flag2=value2 ..."
 ```
 
-In addition to the flags used when starting the kubelet, the file also contains dynamic
-parameters such as the cgroup driver and whether to use a different CRI runtime socket
-(`--cri-socket`).
+kubelet起動時に渡されるフラグに加えて、このファイルはcgroupドライバーや異なるCRIランタイムソケットを使用するかどうか(`--cri-socket`)といった動的なパラメータも含みます。
 
-After marshalling these two files to disk, kubeadm attempts to run the following two
-commands, if you are using systemd:
+これら二つのファイルがディスク上に格納されると、systemdを使用している場合、kubeadmは以下の二つのコマンドを実行します。
 
 ```bash
 systemctl daemon-reload && systemctl restart kubelet
 ```
 
-If the reload and restart are successful, the normal `kubeadm init` workflow continues.
+リロードと再起動に成功すると、通常の`kubeadm init`のワークフローが続きます。
 
 ### `kubeadm join`実行時の流れ
 
-When you run `kubeadm join`, kubeadm uses the Bootstrap Token credential to perform
-a TLS bootstrap, which fetches the credential needed to download the
-`kubelet-config-1.X` ConfigMap and writes it to `/var/lib/kubelet/config.yaml`. The dynamic
-environment file is generated in exactly the same way as `kubeadm init`.
+`kubeadm join`を実行した場合、kubeadmはBootstrap Token証明書を使用してTLS bootstrapを行い、ConfigMap`kubelet-config-1.X`をダウンロードするために必要なクレデンシャルを取得し、`/var/lib/kubelet/config.yaml`へ書き込みます。動的な環境ファイルは、`kubeadm init`の場合と全く同様の方法で生成されます。
 
-Next, `kubeadm` runs the following two commands to load the new configuration into the kubelet:
+次に、`kubeadm`は、kubeletに新たな設定を読み込むために、以下の二つのコマンドを実行します。
 
 ```bash
 systemctl daemon-reload && systemctl restart kubelet
 ```
 
-After the kubelet loads the new configuration, kubeadm writes the
-`/etc/kubernetes/bootstrap-kubelet.conf` KubeConfig file, which contains a CA certificate and Bootstrap
-Token. These are used by the kubelet to perform the TLS Bootstrap and obtain a unique
-credential, which is stored in `/etc/kubernetes/kubelet.conf`. When this file is written, the kubelet
-has finished performing the TLS Bootstrap.
+kubeletが新たな設定を読み込むと、kubeadmは、KubeConfigファイル`/etc/kubernetes/bootstrap-kubelet.conf`を書き込みます。これは、CA証明書とBootstrap Tokenを含みます。これらはkubeletがTLS Bootstrapを行い`/etc/kubernetes/kubelet.conf`に格納されるユニークなクレデンシャルを取得するために使用されます。ファイルが書き込まれると、kubeletはTLS Bootstrapを終了します。
 
-##  kubelet用のsystemdファイル
+## kubelet用のsystemdファイル {#the-kubelet-drop-in-file-for-systemd}
 
-The configuration file installed by the kubeadm DEB or RPM package is written to
-`/etc/systemd/system/kubelet.service.d/10-kubeadm.conf` and is used by systemd.
+`kubeadm`には、systemdがどのようにkubeletを実行するかを指定した設定ファイルが同梱されています。
+kubeadm CLIコマンドは決してこのsystemdファイルには触れないことに注意してください。
+
+kubeadmの[DEBパッケージ](https://github.com/kubernetes/kubernetes/blob/master/build/debs/10-kubeadm.conf)または[RPMパッケージ](https://github.com/kubernetes/kubernetes/blob/master/build/rpms/10-kubeadm.conf)によってインストールされたこの設定ファイルは、`/etc/systemd/system/kubelet.service.d/10-kubeadm.conf`に書き込まれ、systemdで使用されます。基本的な`kubelet.service`([RPM用](https://github.com/kubernetes/release/blob/master/cmd/kubepkg/templates/latest/rpm/kubelet/kubelet.service)または、 [DEB用](https://github.com/kubernetes/release/blob/master/cmd/kubepkg/templates/latest/deb/kubelet/lib/systemd/system/kubelet.service))を拡張します。
 
 ```none
 [Service]
 Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf
 --kubeconfig=/etc/kubernetes/kubelet.conf"
 Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
-# This is a file that "kubeadm init" and "kubeadm join" generates at runtime, populating
+# This is a file that "kubeadm init" and "kubeadm join" generate at runtime, populating
 the KUBELET_KUBEADM_ARGS variable dynamically
 EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
 # This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably,
@@ -174,27 +117,22 @@ ExecStart=
 ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS
 ```
 
-This file specifies the default locations for all of the files managed by kubeadm for the kubelet.
+このファイルは、kubeadmがkubelet用に管理する全ファイルが置かれるデフォルトの場所を指定します。
 
-- The KubeConfig file to use for the TLS Bootstrap is `/etc/kubernetes/bootstrap-kubelet.conf`,
-  but it is only used if `/etc/kubernetes/kubelet.conf` does not exist.
-- The KubeConfig file with the unique kubelet identity is `/etc/kubernetes/kubelet.conf`.
-- The file containing the kubelet's ComponentConfig is `/var/lib/kubelet/config.yaml`.
-- The dynamic environment file that contains `KUBELET_KUBEADM_ARGS` is sourced from `/var/lib/kubelet/kubeadm-flags.env`.
-- The file that can contain user-specified flag overrides with `KUBELET_EXTRA_ARGS` is sourced from
-  `/etc/default/kubelet` (for DEBs), or `/etc/sysconfig/kubelet` (for RPMs). `KUBELET_EXTRA_ARGS`
-  is last in the flag chain and has the highest priority in the event of conflicting settings.
+- TLS Bootstrapに使用するKubeConfigファイルは`/etc/kubernetes/bootstrap-kubelet.conf`ですが、`/etc/kubernetes/kubelet.conf`が存在しない場合にのみ使用します。
+- ユニークなkublet識別子を含むKubeConfigファイルは`/etc/kubernetes/kubelet.conf`です。
+- kubeletのComponentConfigを含むファイルは`/var/lib/kubelet/config.yaml`です。
+- `KUBELET_KUBEADM_ARGS`を含む動的な環境ファイルは`/var/lib/kubelet/kubeadm-flags.env`から取得します。
+- `KUBELET_EXTRA_ARGS`によるユーザー定義のフラグの上書きを格納できるファイルは`/etc/default/kubelet`(DEBの場合)、または`/etc/sysconfig/kubelet`(RPMの場合)から取得します。`KUBELET_EXTRA_ARGS`はフラグの連なりの最後に位置し、優先度が最も高いです。
 
 ## Kubernetesバイナリとパッケージの内容
 
-The DEB and RPM packages shipped with the Kubernetes releases are:
+Kubernetesに同梱されるDEB、RPMのパッケージは以下の通りです。
 
-| Package name | Description |
+| パッケージ名 | 説明        |
 |--------------|-------------|
-| `kubeadm`    | Installs the `/usr/bin/kubeadm` CLI tool and the [kubelet drop-in file](#the-kubelet-drop-in-file-for-systemd) for the kubelet. |
-| `kubelet`    | Installs the `/usr/bin/kubelet` binary. |
-| `kubectl`    | Installs the `/usr/bin/kubectl` binary. |
-| `kubernetes-cni` | Installs the official CNI binaries into the `/opt/cni/bin` directory. |
-| `cri-tools` | Installs the `/usr/bin/crictl` binary from the [cri-tools git repository](https://github.com/kubernetes-incubator/cri-tools). |
-
-
+| `kubeadm`    | `/usr/bin/kubeadm`CLIツールと、[kubelet用のsystemdファイル](#the-kubelet-drop-in-file-for-systemd)をインストールします。 |
+| `kubelet`    | `/usr/bin/kubelet`バイナリをインストールします。 |
+| `kubectl`    | `/usr/bin/kubectl`バイナリをインストールします。 |
+| `kubernetes-cni` | 公式のCNIバイナリを`/opt/cni/bin`ディレクトリにインストールします。 |
+| `cri-tools` | `/usr/bin/crictl`バイナリを[cri-tools gitリポジトリ](https://github.com/kubernetes-incubator/cri-tools)からインストールします。 |
diff --git a/content/ja/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm.md b/content/ja/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm.md
index 90725de1d4..0d73dc2df6 100644
--- a/content/ja/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm.md
+++ b/content/ja/docs/setup/production-environment/tools/kubeadm/setup-ha-etcd-with-kubeadm.md
@@ -6,6 +6,14 @@ weight: 70
 
 <!-- overview -->
 
+{{< note >}}
+While kubeadm is being used as the management tool for external etcd nodes
+in this guide, please note that kubeadm does not plan to support certificate rotation
+or upgrades for such nodes. The long term plan is to empower the tool
+[etcdadm](https://github.com/kubernetes-sigs/etcdadm) to manage these
+aspects.
+{{< /note >}}
+
 Kubeadm defaults to running a single member etcd cluster in a static pod managed
 by the kubelet on the control plane node. This is not a high availability setup
 as the etcd cluster contains only one member and cannot sustain any members
@@ -52,7 +60,8 @@ this example.
     cat << EOF > /etc/systemd/system/kubelet.service.d/20-etcd-service-manager.conf
     [Service]
     ExecStart=
-    ExecStart=/usr/bin/kubelet --address=127.0.0.1 --pod-manifest-path=/etc/kubernetes/manifests
+    #  Replace "systemd" with the cgroup driver of your container runtime. The default value in the kubelet is "cgroupfs".
+    ExecStart=/usr/bin/kubelet --address=127.0.0.1 --pod-manifest-path=/etc/kubernetes/manifests --cgroup-driver=systemd
     Restart=always
     EOF
 
@@ -81,7 +90,7 @@ this example.
     HOST=${ETCDHOSTS[$i]}
     NAME=${NAMES[$i]}
     cat << EOF > /tmp/${HOST}/kubeadmcfg.yaml
-    apiVersion: "kubeadm.k8s.io/v1beta1"
+    apiVersion: "kubeadm.k8s.io/v1beta2"
     kind: ClusterConfiguration
     etcd:
         local:
@@ -241,15 +250,17 @@ this example.
     ```sh
     docker run --rm -it \
     --net host \
-    -v /etc/kubernetes:/etc/kubernetes quay.io/coreos/etcd:${ETCD_TAG} etcdctl \
-    --cert-file /etc/kubernetes/pki/etcd/peer.crt \
-    --key-file /etc/kubernetes/pki/etcd/peer.key \
-    --ca-file /etc/kubernetes/pki/etcd/ca.crt \
-    --endpoints https://${HOST0}:2379 cluster-health
+    -v /etc/kubernetes:/etc/kubernetes k8s.gcr.io/etcd:${ETCD_TAG} etcdctl \
+    --cert /etc/kubernetes/pki/etcd/peer.crt \
+    --key /etc/kubernetes/pki/etcd/peer.key \
+    --cacert /etc/kubernetes/pki/etcd/ca.crt \
+    --endpoints https://${HOST0}:2379 endpoint health --cluster
     ...
-    cluster is healthy
+    https://[HOST0 IP]:2379 is healthy: successfully committed proposal: took = 16.283339ms
+    https://[HOST1 IP]:2379 is healthy: successfully committed proposal: took = 19.44402ms
+    https://[HOST2 IP]:2379 is healthy: successfully committed proposal: took = 35.926451ms
     ```
-    - Set `${ETCD_TAG}` to the version tag of your etcd image. For example `v3.2.24`.
+    - Set `${ETCD_TAG}` to the version tag of your etcd image. For example `3.4.3-0`. To see the etcd image and tag that kubeadm uses execute `kubeadm config images list --kubernetes-version ${K8S_VERSION}`, where `${K8S_VERSION}` is for example `v1.17.0`
     - Set `${HOST0}`to the IP address of the host you are testing.
 
 
diff --git a/content/ja/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm.md b/content/ja/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm.md
index 669cc3a302..8e9067a4eb 100644
--- a/content/ja/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm.md
+++ b/content/ja/docs/setup/production-environment/tools/kubeadm/troubleshooting-kubeadm.md
@@ -1,7 +1,7 @@
 ---
 title: kubeadmのトラブルシューティング
 content_type: concept
-weight: 90
+weight: 20
 ---
 
 <!-- overview -->
@@ -152,7 +152,7 @@ Unable to connect to the server: x509: certificate signed by unknown authority (
 
 - Verify that the `$HOME/.kube/config` file contains a valid certificate, and
   regenerate a certificate if necessary. The certificates in a kubeconfig file
-  are base64 encoded. The `base64 -d` command can be used to decode the certificate
+  are base64 encoded. The `base64 --decode` command can be used to decode the certificate
   and `openssl x509 -text -noout` can be used for viewing the certificate information.
 - Unset the `KUBECONFIG` environment variable using:
 
@@ -170,6 +170,7 @@ Unable to connect to the server: x509: certificate signed by unknown authority (
 
   ```sh
   mv  $HOME/.kube $HOME/.kube.bak
+  mkdir $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/config
   ```
@@ -197,15 +198,15 @@ Error from server: Get https://10.19.0.41:10250/containerLogs/default/mysql-ddc6
 ```
 
 - This may be due to Kubernetes using an IP that can not communicate with other IPs on the seemingly same subnet, possibly by policy of the machine provider.
-- Digital Ocean assigns a public IP to `eth0` as well as a private one to be used internally as anchor for their floating IP feature, yet `kubelet` will pick the latter as the node's `InternalIP` instead of the public one.
+- DigitalOcean assigns a public IP to `eth0` as well as a private one to be used internally as anchor for their floating IP feature, yet `kubelet` will pick the latter as the node's `InternalIP` instead of the public one.
 
-  Use `ip addr show` to check for this scenario instead of `ifconfig` because `ifconfig` will not display the offending alias IP address. Alternatively an API endpoint specific to Digital Ocean allows to query for the anchor IP from the droplet:
+  Use `ip addr show` to check for this scenario instead of `ifconfig` because `ifconfig` will not display the offending alias IP address. Alternatively an API endpoint specific to DigitalOcean allows to query for the anchor IP from the droplet:
 
   ```sh
   curl http://169.254.169.254/metadata/v1/interfaces/public/0/anchor_ipv4/address
   ```
 
-  The workaround is to tell `kubelet` which IP to use using `--node-ip`. When using Digital Ocean, it can be the public one (assigned to `eth0`) or the private one (assigned to `eth1`) should you want to use the optional private network. The [`KubeletExtraArgs` section of the kubeadm `NodeRegistrationOptions` structure](https://github.com/kubernetes/kubernetes/blob/release-1.13/cmd/kubeadm/app/apis/kubeadm/v1beta1/types.go) can be used for this.
+  The workaround is to tell `kubelet` which IP to use using `--node-ip`. When using DigitalOcean, it can be the public one (assigned to `eth0`) or the private one (assigned to `eth1`) should you want to use the optional private network. The [`KubeletExtraArgs` section of the kubeadm `NodeRegistrationOptions` structure](https://github.com/kubernetes/kubernetes/blob/release-1.13/cmd/kubeadm/app/apis/kubeadm/v1beta1/types.go) can be used for this.
 
   Then restart `kubelet`:
 
@@ -306,16 +307,56 @@ The tracking issue for this problem is [here](https://github.com/kubernetes/kube
 
 *Note: This [issue](https://github.com/kubernetes/kubeadm/issues/1358) only applies to tools that marshal kubeadm types (e.g. to a YAML configuration file). It will be fixed in kubeadm API v1beta2.*
 
-By default, kubeadm applies the `role.kubernetes.io/master:NoSchedule` taint to control-plane nodes.
+By default, kubeadm applies the `node-role.kubernetes.io/master:NoSchedule` taint to control-plane nodes.
 If you prefer kubeadm to not taint the control-plane node, and set `InitConfiguration.NodeRegistration.Taints` to an empty slice,
 the field will be omitted when marshalling. When the field is omitted, kubeadm applies the default taint.
 
 There are at least two workarounds:
 
-1. Use the `role.kubernetes.io/master:PreferNoSchedule` taint instead of an empty slice. [Pods will get scheduled on masters](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/), unless other nodes have capacity.
+1. Use the `node-role.kubernetes.io/master:PreferNoSchedule` taint instead of an empty slice. [Pods will get scheduled on masters](/docs/concepts/configuration/taint-and-toleration/), unless other nodes have capacity.
 
 2. Remove the taint after kubeadm init exits:
 ```bash
-kubectl taint nodes NODE_NAME role.kubernetes.io/master:NoSchedule-
+kubectl taint nodes NODE_NAME node-role.kubernetes.io/master:NoSchedule-
+ ```
+
+## `/usr` is mounted read-only on nodes {#usr-mounted-read-only}
+
+On Linux distributions such as Fedora CoreOS, the directory `/usr` is mounted as a read-only filesystem.
+For [flex-volume support](https://github.com/kubernetes/community/blob/ab55d85/contributors/devel/sig-storage/flexvolume.md),
+Kubernetes components like the kubelet and kube-controller-manager use the default path of
+`/usr/libexec/kubernetes/kubelet-plugins/volume/exec/`, yet the flex-volume directory _must be writeable_
+for the feature to work.
+
+To workaround this issue you can configure the flex-volume directory using the kubeadm
+[configuration file](https://godoc.org/k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2).
+
+On the primary control-plane Node (created using `kubeadm init`) pass the following
+file using `--config`:
+
+```yaml
+apiVersion: kubeadm.k8s.io/v1beta2
+kind: InitConfiguration
+nodeRegistration:
+  kubeletExtraArgs:
+    volume-plugin-dir: "/opt/libexec/kubernetes/kubelet-plugins/volume/exec/"
+---
+apiVersion: kubeadm.k8s.io/v1beta2
+kind: ClusterConfiguration
+controllerManager:
+  extraArgs:
+    flex-volume-plugin-dir: "/opt/libexec/kubernetes/kubelet-plugins/volume/exec/"
 ```
 
+On joining Nodes:
+
+```yaml
+apiVersion: kubeadm.k8s.io/v1beta2
+kind: JoinConfiguration
+nodeRegistration:
+  kubeletExtraArgs:
+    volume-plugin-dir: "/opt/libexec/kubernetes/kubelet-plugins/volume/exec/"
+```
+
+Alternatively, you can modify `/etc/fstab` to make the `/usr` mount writeable, but please
+be advised that this is modifying a design principle of the Linux distribution.