kubernetes
/
website
mirror of https://github.com/kubernetes/website.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update with master content resolving merge conflicts

This commit is contained in:
MAKOSCAFEE 2019-06-19 19:10:18 +03:00
parent b42f019aae 42cbe1256e
commit 8781518d32
1439 changed files with 70927 additions and 43295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.github/ISSUE_TEMPLATE.md → .github/ISSUE_TEMPLATE/bug-report.md vendored
View File

@ -1,19 +1,19 @@
---
name: Bug Report
about: Report a bug encountered with Kubernetes Website
labels:
- kind/bug
---
**This is a Bug Report**
<!-- Thanks for filing an issue! Before submitting, please fill in the following information. -->
<!-- See https://kubernetes.io/docs/contribute/start/ for guidance on writing an actionable issue description. -->
<!--Required Information-->
**This is a...**
<!-- choose one by changing [ ] to [x] -->
- [ ] Feature Request
- [ ] Bug Report
**Problem:**
**Proposed Solution:**
**Page to Update:**
https://kubernetes.io/...

18
.github/ISSUE_TEMPLATE/feature-request.md vendored Normal file
View File

@ -0,0 +1,18 @@
---
name: Feature Request
about: Suggest a/an feature/enhancement to the Kubernetes Website project
labels:
- kind/feature
---
**This is a Feature Request**
<!-- Please only use this template for submitting feature/enhancement requests -->
<!-- See https://kubernetes.io/docs/contribute/start/ for guidance on writing an actionable issue description. -->
**What would you like to be added**
<!-- Describe as precisely as possible how this feature/enhancement should work from the user perspective. What should be changed, etc. -->
**Why is this needed**
**Comments**
<!-- Any additional related comments that might help. Drawings/mockups would be extremely helpful (if required). -->

19
.github/ISSUE_TEMPLATE/support.md vendored Normal file
View File

@ -0,0 +1,19 @@
---
name: Support Request
about: Support request or question relating to Kubernetes Dashboard project
labels:
- triage/support
---
**This is Support**
<!--
STOP -- PLEASE READ!
GitHub is not the right place for support requests.
If you're looking for help, check [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes)
You can also post your question on the [Kubernetes Slack](http://slack.k8s.io/) or the [Discuss Kubernetes](https://discuss.kubernetes.io/) forum.
If the matter is security related, please disclose it privately via https://kubernetes.io/security/.
-->

12
.github/PULL_REQUEST_TEMPLATE.md vendored
View File

@ -1,16 +1,16 @@
>^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> Please delete this note before submitting the pull request.
> Remember to delete this note before submitting your pull request.
>
> For 1.14 Features: set Milestone to 1.14 and Base Branch to dev-1.14
> For pull requests on 1.15 Features: set Milestone to 1.15 and Base Branch to dev-1.15
>
> For Chinese localization, base branch to release-1.12
> For pull requests on Chinese localization, set Base Branch to release-1.14
>
> For Korean Localization: set Base Branch to dev-1.13-ko.<latest team milestone>
> For pull requests on Korean Localization: set Base Branch to dev-1.14-ko.\<latest team milestone>
>
> Help editing and submitting pull requests:
> If you need Help on editing and submitting pull requests, visit:
> https://kubernetes.io/docs/contribute/start/#improve-existing-content.
>
> Help choosing which branch to use:
> If you need Help on choosing which branch to use, visit:
> https://kubernetes.io/docs/contribute/start#choose-which-git-branch-to-use.
>^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>

1
.gitignore vendored
View File

@ -1,7 +1,6 @@
**/.DS_Store
**/desktop.ini
_site/**
.sass-cache/**
CNAME
.travis.yml
.idea/

2
Dockerfile
View File

@ -20,7 +20,7 @@ ARG HUGO_VERSION
RUN mkdir -p /usr/local/src && \
cd /usr/local/src && \
curl -L https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_${HUGO_VERSION}_linux-64bit.tar.gz | tar -xz && \
curl -L https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_extended_${HUGO_VERSION}_Linux-64bit.tar.gz | tar -xz && \
mv hugo /usr/local/bin/hugo && \
addgroup -Sg 1000 hugo && \
adduser -Sg hugo -u 1000 -h /src hugo

19
Makefile
View File

@ -5,7 +5,7 @@ DOCKER_RUN = $(DOCKER) run --rm --interactive --tty --volume $(CURDIR):/src
NODE_BIN = node_modules/.bin
NETLIFY_FUNC = $(NODE_BIN)/netlify-lambda
.PHONY: all build sass build-preview help serve
.PHONY: all build build-preview help serve
help: ## Show this help.
@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {sub("\\\\n",sprintf("\n%22c"," "), $$2);printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
@ -26,15 +26,9 @@ check-headers-file:
production-build: check-hugo-versions build check-headers-file ## Build the production site and ensure that noindex headers aren't added
non-production-build: check-hugo-versions ## Build the non-production site, which adds noindex headers to prevent indexing
non-production-build: test-examples check-hugo-versions ## Build the non-production site, which adds noindex headers to prevent indexing
hugo --enableGitInfo
sass-build:
scripts/sass.sh build
sass-develop:
scripts/sass.sh develop
serve: ## Boot the development server.
hugo server --buildFuture
@ -47,12 +41,9 @@ docker-build:
docker-serve:
$(DOCKER_RUN) -p 1313:1313 $(DOCKER_IMAGE) hugo server --buildFuture --bind 0.0.0.0
# This command is used only by Travis CI; do not run this locally
travis-hugo-build:
curl -L https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_${HUGO_VERSION}_linux-64bit.tar.gz | tar -xz
mkdir -p ${TRAVIS_HOME}/bin
mv hugo ${TRAVIS_HOME}/bin
export PATH=${TRAVIS_HOME}/bin:$PATH
test-examples:
scripts/test_examples.sh install
scripts/test_examples.sh run
check-hugo-versions:
scripts/hugo-version-check.sh $(HUGO_VERSION)

45
OWNERS_ALIASES
View File

@ -20,9 +20,11 @@ aliases:
- dixudx
sig-docs-de-owners: # Admins for German content
- bene2k1
- mkorbi
- rlenferink
sig-docs-de-reviews: # PR reviews for German content
- bene2k1
- mkorbi
- rlenferink
sig-docs-en-owners: # Admins for English content
- bradamant3
@ -32,6 +34,7 @@ aliases:
- jaredbhatti
- jimangel
- kbarnard10
- makoscafee
- mistyhacks
- rajakavitha1
- ryanmcginnis
@ -48,11 +51,18 @@ aliases:
- stewart-yu
- xiangpengzhao
- zhangxiaoyu-zidif
sig-docs-es-owners: # Admins for Spanish content
- raelga
- alexbrand
sig-docs-es-reviews: # PR reviews for Spanish content
- raelga
- alexbrand
- glo-pena
- electrocucaracha
sig-docs-fr-owners: # Admins for French content
- sieben
- remyleone
- perriea
- rekcah78
- lledru
- yastij
- smana
- rbenzair
@ -62,10 +72,9 @@ aliases:
- awkif
- oussemos
sig-docs-fr-reviews: # PR reviews for French content
- sieben
- remyleone
- perriea
- rekcah78
- lledru
- yastij
- smana
- rbenzair
@ -74,20 +83,34 @@ aliases:
- jygastaud
- awkif
- oussemos
sig-docs-hi-owners: # Admins for Hindi content
- avidLearnerInProgress
- daminisatya
- mittalyashu
- Rajakavitha1
sig-docs-hi-reviews: # PR reviews for Hindi content
- avidLearnerInProgress
- daminisatya
- mittalyashu
- Rajakavitha1
sig-docs-id-owners: # Admins for Indonesian content
- girikuncoro
- irvifa
sig-docs-id-reviews: # PR reviews for Indonesian content
- girikuncoro
- irvifa
sig-docs-it-owners: # Admins for Italian content
- rlenferink
- lledru
- micheleberardi
sig-docs-it-reviews: # PR reviews for Italian content
- rlenferink
- lledru
- micheleberardi
sig-docs-ja-owners: # Admins for Japanese content
- cstoku
- nasa9084
- tnir
- zacharysarah
sig-docs-ja-reviews: # PR reviews for Italian content
sig-docs-ja-reviews: # PR reviews for Japanese content
- cstoku
- makocchi-git
- MasayaAoyama
@ -102,6 +125,7 @@ aliases:
- ClaudiaJKang
- gochist
- ianychoi
- seokho-son
sig-docs-maintainers: # Website maintainers
- bradamant3
- chenopis
@ -140,4 +164,9 @@ aliases:
- xichengliudui
- zhangxiaoyu-zidif
- pigletfly
sig-docs-pt-owners: # Admins for Portuguese content
- femrtnz
- jcjesus
sig-docs-pt-reviews: # PR reviews for Portugese content
- femrtnz
- jcjesus

18
README-de.md
View File

@ -7,9 +7,9 @@ Herzlich willkommen! Dieses Repository enthält alle Assets, die zur Erstellung
## Beiträge zur Dokumentation
Sie können auf die Schaltfläche **Fork** im oberen rechten Bereich des Bildschirms klicken, um eine Kopie dieses Repositorys in Ihrem GitHub-Konto zu erstellen. Diese Kopie wird als *Fork* bezeichnet. Nehmen Sie die gewünschten Änderungen an Ihrem Fork vor. Wenn Sie bereit sind, diese Änderungen an uns zu senden, gehen Sie zu Ihrem Form und erstellen Sie eine neue Pull-Anforderung, um uns darüber zu informieren.
Sie können auf die Schaltfläche **Fork** im oberen rechten Bereich des Bildschirms klicken, um eine Kopie dieses Repositorys in Ihrem GitHub-Konto zu erstellen. Diese Kopie wird als *Fork* bezeichnet. Nehmen Sie die gewünschten Änderungen an Ihrem Fork vor. Wenn Sie bereit sind, diese Änderungen an uns zu senden, gehen Sie zu Ihrem Fork und erstellen Sie eine neue Pull-Anforderung, um uns darüber zu informieren.
Sobald Ihre Pull-Anfrage erstellt wurde, übernimmt ein Rezensent von Kubernetes die Verantwortung für klares, umsetzbares Feedback. Als Eigentümer des Pull-Request **liegt es in Ihrer Verantwortung Ihren Pull-Reqest enstsprechend des Feedbacks, dass Sie vom Kubernetes-Reviewer erhalten haben abzuändern.** Beachten Sie auch, dass Sie am Ende mehr als einen Rezensenten von Kubernetes erhalten, der Ihnen Feedback gibt, oder dass Sie Rückmeldungen von einem Rezensenten von Kubernetes erhalten, der sich von demjenigen unterscheidet, der ursprünglich für das Feedback zugewiesen wurde. In einigen Fällen kann es vorkommen, dass einer Ihrer Prüfer bei Bedarf eine technische Überprüfung von einem [Kubernetes Techn-Reviewer] (https://github.com/kubernetes/website/wiki/tech-reviewers) anfordert. Reviewer geben ihr Bestes, um zeitnah Feedback zu geben, die Antwortzeiten können jedoch je nach den Umständen variieren.
Sobald Ihre Pull-Anfrage erstellt wurde, übernimmt ein Rezensent von Kubernetes die Verantwortung für klares, umsetzbares Feedback. Als Eigentümer des Pull-Request **liegt es in Ihrer Verantwortung Ihren Pull-Reqest enstsprechend des Feedbacks, dass Sie vom Kubernetes-Reviewer erhalten haben abzuändern.** Beachten Sie auch, dass Sie am Ende mehr als einen Rezensenten von Kubernetes erhalten, der Ihnen Feedback gibt, oder dass Sie Rückmeldungen von einem Rezensenten von Kubernetes erhalten, der sich von demjenigen unterscheidet, der ursprünglich für das Feedback zugewiesen wurde. In einigen Fällen kann es vorkommen, dass einer Ihrer Prüfer bei Bedarf eine technische Überprüfung von einem [Kubernetes Tech-Reviewer](https://github.com/kubernetes/website/wiki/tech-reviewers) anfordert. Reviewer geben ihr Bestes, um zeitnah Feedback zu geben, die Antwortzeiten können jedoch je nach den Umständen variieren.
Weitere Informationen zum Beitrag zur Kubernetes-Dokumentation finden Sie unter:
@ -21,14 +21,12 @@ Weitere Informationen zum Beitrag zur Kubernetes-Dokumentation finden Sie unter:
## `README.md`'s Localizing Kubernetes Documentation
### Koreanisch
### Deutsch
Die Betreuer der deutschen Lokalisierung erreichen Sie unter:
Lesen Sie die Übersetzung von `README.md` und detailliertere Anleitungen für koreanische Mitwirkende auf der Seite [Koreanischen README] (README-ko.md).
Sie können die Betreuer der koreanischen Lokalisierung erreichen unter:
* June Yi ([GitHub - @gochist](https://github.com/gochist))
* [Slack Kanal](https://kubernetes.slack.com/messages/kubernetes-docs-ko)
* Benedikt Rollik ([@bene2k1](https://github.com/bene2k1))
* Max Körbächer ([@mkorbi](https://github.com/mkorbi))
* [Slack Kanal](https://kubernetes.slack.com/messages/kubernetes-docs-de)
## Site lokal mit Docker ausführen
@ -76,7 +74,7 @@ Sie können die Betreuer dieses Projekts unter folgender Adresse erreichen:
### Verhaltensregeln
Die Teilnahme an der Kubernetes-Community unterliegt dem [Kubernetes-Verhaltenskodex] (code-of-conduct.md).
Die Teilnahme an der Kubernetes-Community unterliegt dem [Kubernetes-Verhaltenskodex](code-of-conduct.md).
## Vielen Dank!

76
README-es.md Normal file
View File

@ -0,0 +1,76 @@
# La documentación de Kubernetes
[![Build Status](https://api.travis-ci.org/kubernetes/website.svg?branch=master)](https://travis-ci.org/kubernetes/website)
[![GitHub release](https://img.shields.io/github/release/kubernetes/website.svg)](https://github.com/kubernetes/website/releases/latest)
Bienvenido!
Este repositorio contiene todos los recursos necesarios para construir el [sitio web de Kubernetes y su documentación](https://kubernetes.io/). ¡Estamos encantados de que quiera contribuir!
## Contribuyendo con la documentación
Puede hacer clic en el botón **Fork** situado en la esquina superior derecha de la pantalla para crear una copia de este repositorio en su cuenta de GitHub. A ese tipo de copia se le llama **Fork** (bifurcación) y le permite editar el contenido del repositorio en su copia personal. Realice los cambios que quiera en su **fork** y, cuando esté listo para enviarnos esos cambios, vaya a **fork** en repositorio en su GitHub y cree una nueva **pull request** para que tengamos constancia de la propuesta de cambios.
Una vez la **pull request** ha sido creada, un revisor de Kubernetes asumirá la responsabilidad de proporcionar comentarios claros y prácticos sobre como continuar. Como propietario de la PR, **es su responsabilidad modificar la pull request para abordar los comentarios proporcionados por el revisor de Kubernetes.** Tenga en cuenta que algunas veces puede terminar teniendo más de un revisor de Kubernetes participando en la revisión, por lo que es posible que reciba comentarios de más revisores a parte del asignado originalmente en la creación de la **pull request**. Además, en algunas ocasiones, es posible que uno de sus revisores solicite una revisión técnica por parte de un [revisor técnico de Kubernetes](https://github.com/kubernetes/website/wiki/Tech-reviewers) si lo considera necesario.
Los revisores harán todo lo posible para proporcionar toda la información necesaria para que la **pull request** siga adelante en un tiempo razonable, pero este tiempo de respuesta puede variar según las circunstancias.
Para obtener más información sobre cómo contribuir a la documentación de Kubernetes, puede consultar:
* [Empezando a contribuir](https://kubernetes.io/docs/contribute/start/)
* [Visualizando sus cambios en su entorno local](http://kubernetes.io/docs/contribute/intermediate#view-your-changes-locally)
* [Utilizando las plantillas de las páginas](http://kubernetes.io/docs/contribute/style/page-templates/)
* [Guía de estilo de la documentación](http://kubernetes.io/docs/contribute/style/style-guide/)
* [Traduciendo la documentación de Kubernetes](https://kubernetes.io/docs/contribute/localization/)
## Levantando el sitio web kubernetes.io en su entorno local con Docker
El método recomendado para levantar una copia local del sitio web kubernetes.io es utilizando la imagen de [Docker](https://docker.com) que incluye el generador de sitios estáticos [Hugo](https://gohugo.io).
> Para Windows, algunas otras herramientas como Make son necesarias. Puede instalarlas utilizando el gestor [Chocolatey](https://chocolatey.org). `choco install make` o siguiendo las instrucciones de [Make for Windows](http://gnuwin32.sourceforge.net/packages/make.htm).
> Si prefiere levantar el sitio web sin utilizar **Docker**, puede seguir las instrucciones disponibles en la sección [Levantando kubernetes.io en local con Hugo](#levantando-kubernetes.io-en-local-con-hugo).
Una vez tenga Docker [configurado en su máquina](https://www.docker.com/get-started), puede construir la imagen de Docker `kubernetes-hugo` localmente ejecutando el siguiente comando en la raíz del repositorio:
```bash
make docker-image
```
Una vez tenga la imagen construida, puede levantar el sitio web ejecutando:
```bash
make docker-serve
```
Abra su navegador y visite http://localhost:1313 para acceder a su copia local del sitio. A medida que vaya haciendo cambios en el código fuente, Hugo irá actualizando la página y forzará la actualización en el navegador.
## Levantando kubernetes.io en local con Hugo
Revise la [documentación oficial de Hugo](https://gohugo.io/getting-started/installing/) para obtener las instrucciones de instalación en su sistema operativo. Asegúrese de instalar la versión de Hugo especificada en la variable de entorno `HUGO_VERSION` del fichero [`netlify.toml`](netlify.toml#L9).
Para levantar el sitio localmente una vez Hugo está instalado en su sistema, puede ejecutar el siguiente comando:
```bash
make serve
```
Este comando levantará un servidor de Hugo en el puerto **1313** al que podrá acceder visitando http://localhost:1313 y dónde podrá visualizar su copia local del sitio web. A medida que vaya haciendo cambios en el código fuente, Hugo irá actualizando la página y forzará la actualización en el navegador.
## Comunidad, discusión, contribuir y soporte
Aprenda como participar en la comunidad de Kubernetes visitando la [página de comunidad](http://kubernetes.io/community/).
Puede ponerse en contacto con los mantenedores de este proyecto en:
- [Slack](https://kubernetes.slack.com/messages/sig-docs)
- [Mailing List](https://groups.google.com/forum/#!forum/kubernetes-sig-docs)
### Código de conducta
La participación en la comunidad de Kubernetes está regulada por el [Código de Conducta de Kubernetes](code-of-conduct.md).
## ¡Muchas gracias!
Kubernetes es posible gracias a la participación de la comunidad y la documentación es vital para facilitar el acceso al proyecto.
Agradecemos muchísimo sus contribuciones a nuestro sitio web y nuestra documentación.

84
README-hi.md Normal file
View File

@ -0,0 +1,84 @@
# कुबरनेट्स प्रलेखन
[![Build Status](https://api.travis-ci.org/kubernetes/website.svg?branch=master)](https://travis-ci.org/kubernetes/website)
[![GitHub release](https://img.shields.io/github/release/kubernetes/website.svg)](https://github.com/kubernetes/website/releases/latest)
स्वागत हे! इस रिपॉजिटरी में [कुबरनेट्स वेबसाइट और दस्तावेज](https://kubernetes.io/) बनाने के लिए आवश्यक सभी संपत्तियां हैं। हम बहुत खुश हैं कि आप योगदान करना चाहते हैं!
## डॉक्स में योगदान देना
आप अपने GitHub खाते में इस रिपॉजिटरी की एक copy बनाने के लिए स्क्रीन के ऊपरी-दाएँ क्षेत्र में **Fork** बटन पर क्लिक करें। इस copy को *Fork* कहा जाता है। अपने fork में कोई भी परिवर्तन करना चाहते हैं, और जब आप उन परिवर्तनों को हमारे पास भेजने के लिए तैयार हों, तो अपने fork पर जाएं और हमें इसके बारे में बताने के लिए एक नया pull request बनाएं।
एक बार जब आपका pull request बन जाता है, तो एक कुबरनेट्स समीक्षक स्पष्ट, कार्रवाई योग्य प्रतिक्रिया प्रदान करने की जिम्मेदारी लेगा। pull request के मालिक के रूप में, **यह आपकी जिम्मेदारी है कि आप कुबरनेट्स समीक्षक द्वारा प्रदान की गई प्रतिक्रिया को संबोधित करने के लिए अपने pull request को संशोधित करें।**
यह भी ध्यान दें कि आप एक से अधिक कुबरनेट्स समीक्षक आपको प्रतिक्रिया प्रदान कर सकते हैं या आप एक कुबरनेट्स समीक्षक से प्रतिक्रिया प्राप्त कर सकते हैं जो मूल रूप से आपको प्रतिक्रिया प्रदान करने के लिए दिए गए एक से भिन्न है। इसके अलावा, कुछ मामलों में, आपका एक समीक्षक जरूरत पड़ने पर [कुबेरनेट्स टेक समीक्षक](https://github.com/kubernetes/website/wiki/Tech-reviewers) से तकनीकी समीक्षा प्राप्त कर सकता है। समीक्षक समय पर प्रतिक्रिया देने के लिए पूरी कोशिश करेंगे, लेकिन परिस्थितियों के आधार पर प्रतिक्रिया समय अलग-अलग हो सकता है।
कुबरनेट्स प्रलेखन में योगदान देने के बारे में अधिक जानकारी के लिए, देखें:
* [योगदान देना शुरू करें](https://kubernetes.io/docs/contribute/start/)
* [परिवर्तनों को अंतिम चरण में लेजाएं](http://kubernetes.io/docs/contribute/intermediate#view-your-changes-locally)
* [पेज टेम्पलेट](http://kubernetes.io/docs/contribute/style/page-templates/)
* [प्रलेखन शैली गाइड](http://kubernetes.io/docs/contribute/style/style-guide/)
* [स्थानीयकरण कुबरनेट्स प्रलेखन](https://kubernetes.io/docs/contribute/localization/)
## `README.md`'s स्थानीयकरण कुबरनेट्स प्रलेखन
आप पर हिंदी स्थानीयकरण के maintainers तक पहुँच सकते हैं:
* Yashu Mittal ([Twitter](https://twitter.com/mittalyashu77), [GitHub](https://github.com/mittalyashu))
* [Slack channel](https://kubernetes.slack.com/messages/kubernetes-docs-hi)
## स्थानीय रूप से डॉकर का उपयोग करके साइट चलाना
कुबरनेट्स वेबसाइट को स्थानीय रूप से चलाने के लिए अनुशंसित तरीका एक विशेष [डॉकर](https://docker.com) image को चलाना है, जिसमें [Hugo](https://gohugo.io) स्टेटिक साइट जनरेटर शामिल है।
> यदि आप विंडोज पर हैं, तो आपको कुछ और टूल्स की आवश्यकता होगी जिन्हें आप [Chocolatey](https://chocolatey.org) के साथ इंस्टॉल कर सकते हैं।
> यदि आप डॉकर के बिना स्थानीय रूप से वेबसाइट चलाना पसंद करते हैं, तो नीचे Hugo का उपयोग करके स्थानीय रूप से साइट चलाना देखें।
यदि आप डॉकर के बिना स्थानीय रूप से वेबसाइट चलाना पसंद करते हैं, तो नीचे दिए गए Hugo का उपयोग करके स्थानीय रूप से [साइट को चलाने](#running-the-site-locally-using-hugo) का तरीका देखें।
यदि आप [डॉकर](https://www.docker.com/get-started) चला रहे हैं, तो स्थानीय रूप से `कुबेरनेट्स-ह्यूगो` Docker image बनाएँ:
```bash
make docker-image
```
एक बार image बन जाने के बाद, आप साइट को स्थानीय रूप से चला सकते हैं:
```bash
make docker-serve
```
साइट देखने के लिए अपने browser को `http://localhost:1313` पर खोलें। जैसा कि आप source फ़ाइलों में परिवर्तन करते हैं, Hugo साइट को अपडेट करता है और browser को refresh करने पर मजबूर करता है।
## Hugo का उपयोग करते हुए स्थानीय रूप से साइट चलाना
Hugo निर्देशों के लिए [आधिकारिक Hugo प्रलेखन](https://gohugo.io/getting-started/installing/) देखें। [`Netlify.toml`](netlify.toml#L9) फ़ाइल में `HUGO_VERSION` environment variable द्वारा निर्दिष्ट Hugo version को install करना सुनिश्चित करें।
जब आप Hugo को install करते हैं तो स्थानीय रूप से साइट को चलाने के लिए:
```bash
make serve
```
यह पोर्ट `1313` पर Hugo सर्वर को शुरू करेगा। साइट देखने के लिए अपने browser को `http://localhost:1313` पर खोलें। जैसा कि आप source फ़ाइलों में परिवर्तन करते हैं, Hugo साइट को अपडेट करता है और एक browser को refresh करने पर मजबूर करता है।
## समुदाय, चर्चा, योगदान और समर्थन
[Community page](http://kubernetes.io/community/) पर कुबरनेट्स समुदाय के साथ जुड़ना सीखें।
आप इस परियोजना के स्थानीयकरण तक पहुँच सकते हैं:
- [Slack](https://kubernetes.slack.com/messages/sig-docs)
- [Mailing List](https://groups.google.com/forum/#!forum/kubernetes-sig-docs)
## कोड ओफ़ कंडक्ट
कुबरनेट्स समुदाय में भागीदारी [कुबरनेट्स कोड ओफ़ कंडक्ट](https://github.com/cncf/foundation/blob/master/code-of-conduct-languages/hi.md) द्वारा शासित है.
## धन्यवाद!
कुबरनेट्स सामुदायिक भागीदारी पर पनपती है, और हम वास्तव में हमारी साइट और हमारे प्रलेखन में आपके योगदान की सराहना करते हैं!
कुबरनेट्स आपकी भागीदारी पर निर्भर है, और हम हमारी साइट और प्रलेखन में आपके योगदान का मान करते हैं!

72
README-id.md Normal file
View File

@ -0,0 +1,72 @@
# Dokumentasi Kubernetes
[![Build Status](https://api.travis-ci.org/kubernetes/website.svg?branch=master)](https://travis-ci.org/kubernetes/website)
[![GitHub release](https://img.shields.io/github/release/kubernetes/website.svg)](https://github.com/kubernetes/website/releases/latest)
Selamat datang! Repositori ini merupakan wadah bagi semua komponen yang dibutuhkan untuk membuat [dokumentasi Kubernetes](https://kubernetes.io/). Kami merasa sangat senang apabila kamu berminat untuk menjadi kontributor!
## Kontribusi pada dokumentasi
Pertama, kamu dapat menekan tombol **Fork** yang berada pada bagian atas layar, untuk menyalin repositori pada akun Github-mu. Salinan ini disebut sebagai **fork**. Kamu dapat menambahkan konten pada **fork** yang kamu miliki, setelah kamu merasa cukup untuk menambahkan konten yang kamu miliki dan ingin memberikan konten tersebut pada kami, kamu dapat melihat **fork** yang telah kamu buat dan membuat **pull request** untuk memberi tahu kami bahwa kamu ingin menambahkan konten yang telah kamu buat.
Setelah kamu membuat sebuah **pull request**, seorang **reviewer** akan memberikan masukan terhadap konten yang kamu sediakan serta beberapa hal yang dapat kamu lakukan apabila perbaikan diperlukan terhadap konten yang telah kamu sediakan. Sebagai seorang yang membuat **pull request**, **sudah menjadi kewajiban kamu untuk melakukan modifikasi terhadap konten yang kamu berikan sesuai dengan masukan yang diberikan oleh seorang reviewer Kubernetes**. Perlu kamu ketahui bahwa kamu dapat saja memiliki lebih dari satu orang **reviewer Kubernetes** atau dalam kasus kamu bisa saja mendapatkan **reviewer Kubernetes** yang berbeda dengan **reviewer Kubernetes** awal yang ditugaskan untuk memberikan masukan terhadap konten yang kamu sediakan. Selain itu, seorang **reviewer Kubernetes** bisa saja meminta masukan teknis dari [reviewer teknis Kubernetes](https://github.com/kubernetes/website/wiki/Tech-reviewers) jika diperlukan.
Untuk informasi lebih lanjut mengenai tata cara melakukan kontribusi, kamu dapat melihat tautan di bawah ini:
* [Petunjuk Melakukan Kontribusi](https://kubernetes.io/docs/contribute/start/)
* [Melakukan Tahap Staging pada Konten Dokumentasi yang telah Kamu Sediakan](http://kubernetes.io/docs/contribute/intermediate#view-your-changes-locally)
* [Petunjuk Menggunakan Page Templates](http://kubernetes.io/docs/contribute/style/page-templates/)
* [Petunjuk untuk Documentation Style](http://kubernetes.io/docs/contribute/style/style-guide/)
* [Petunjuk untuk Melakukan Lokalisasi Dokumentasi Kubernetes](https://kubernetes.io/docs/contribute/localization/)
## Menjalankan Dokumentasi Kubernetes pada Mesin Lokal Kamu
Petunjuk yang disarankan untuk menjalankan Dokumentasi Kubernetes pada mesin lokal kamus adalah dengan menggunakan [Docker](https://docker.com) **image** yang memiliki **package** [Hugo](https://gohugo.io), **Hugo** sendiri merupakan generator website statis.
> Jika kamu menggunakan Windows, kamu mungkin membutuhkan beberapa langkah tambahan untuk melakukan instalasi perangkat lunak yang dibutuhkan. Instalasi ini dapat dilakukan dengan menggunakan [Chocolatey](https://chocolatey.org). `choco install make`
> Jika kamu ingin menjalankan **website** tanpa menggunakan **Docker**, kamu dapat melihat tautan berikut [Petunjuk untuk menjalankan website pada mesin lokal dengan menggunakan Hugo](#petunjuk-untuk-menjalankan-website-pada-mesin-lokal-denga-menggunakan-hugo) di bagian bawah.
Jika kamu sudah memiliki **Docker** [yang sudah dapat digunakan](https://www.docker.com/get-started), kamu dapat melakukan **build** `kubernetes-hugo` **Docker image** secara lokal:
```bash
make docker-image
```
Setelah **image** berhasil di-**build**, kamu dapat menjalankan website tersebut pada mesin lokal-mu:
```bash
make docker-serve
```
Buka **browser** kamu ke http://localhost:1313 untuk melihat laman dokumentasi. Selama kamu melakukan penambahan konten, **Hugo** akan secara otomatis melakukan perubahan terhadap laman dokumentasi apabila **browser** melakukan proses **refresh**.
## Petunjuk untuk menjalankan website pada mesin lokal dengan menggunakan Hugo
Kamu dapat melihat [dokumentasi resmi Hugo](https://gohugo.io/getting-started/installing/) untuk mengetahui langkah yang diperlukan untuk melakukan instalasi **Hugo**. Pastikan kamu melakukan instalasi versi **Hugo** sesuai dengan versi yang tersedia pada **environment variable** `HUGO_VERSION` pada **file**[`netlify.toml`](netlify.toml#L9).
Untuk menjalankan laman pada mesin lokal setelah instalasi **Hugo**, kamu dapat menjalankan perintah berikut:
```bash
make serve
```
Buka **browser** kamu ke http://localhost:1313 untuk melihat laman dokumentasi. Selama kamu melakukan penambahan konten, **Hugo** akan secara otomatis melakukan perubahan terhadap laman dokumentasi apabila **browser** melakukan proses **refresh**.
## Komunitas, Diskusi, Kontribusi, dan Bantuan
Kamu dapat belajar bagaimana tata cara untuk ikut terlibat dalam komunitas Kubernetes melalui [laman komunitas](http://kubernetes.io/community/).
Kamu dapat berinteraksi dengan **maintainers** project ini melalui:
- [Slack](https://kubernetes.slack.com/messages/sig-docs)
- [Mailing List](https://groups.google.com/forum/#!forum/kubernetes-sig-docs)
### Etika dalam Berkontribusi
Partisipasi dalam komunitas Kubernetes diatur dalam [Etika dalam Berkontribusi pada Kubernetes](code-of-conduct.md).
## Terima Kasih!
Kubernetes sangat menjunjung tinggi partisipasi dari komunitas, dan kami sangat mengapresiasi kontribusi kamu pada laman dan dokumentasi kami!

4
README-ko.md
View File

@ -23,9 +23,9 @@
### 한국어
`README.md` 번역 및 한국어 기여자를 위한 보다 자세한 가이드를 [한국어 README](README-ko.md) 페이지에서 살펴봅니다.
`README.md` 번역 및 한국어 기여자를 위한 보다 자세한 가이드를 [한국어 README](README-ko.md) 페이지 혹은 [쿠버네티스 문서 한글화 가이드](https://kubernetes.io/ko/docs/contribute/localization_ko/)에서 살펴봅니다.
한국어 번역 메인테이너에게 다음을 통해 연락 가능합니다:
한국어 번역 메인테이너에게 다음을 통해 연락 가능합니다.
* 이덕준 ([GitHub - @gochist](https://github.com/gochist))
* [Slack channel](https://kubernetes.slack.com/messages/kubernetes-docs-ko)

82
README-pt.md Normal file
View File

@ -0,0 +1,82 @@
# A documentação do Kubernetes
[![Build Status](https://api.travis-ci.org/kubernetes/website.svg?branch=master)](https://travis-ci.org/kubernetes/website)
[![GitHub release](https://img.shields.io/github/release/kubernetes/website.svg)](https://github.com/kubernetes/website/releases/latest)
Bem vindos! Este repositório abriga todos os recursos necessários para criar o [site e documentação do Kubernetes](https://kubernetes.io/). Estamos muito satisfeitos por você querer contribuir!
## Contribuindo com os documentos
Você pode clicar no botão **Fork** na área superior direita da tela para criar uma cópia desse repositório na sua conta do GitHub. Esta cópia é chamada de *fork*. Faça as alterações desejadas no seu fork e, quando estiver pronto para enviar as alterações para nós, vá até o fork e crie uma nova solicitação de pull para nos informar sobre isso.
Depois que seu **pull request** for criada, um revisor do Kubernetes assumirá a responsabilidade de fornecer um feedback claro e objetivo. Como proprietário do pull request, **é sua responsabilidade modificar seu pull request para abordar o feedback que foi fornecido a você pelo revisor do Kubernetes.** Observe também que você pode acabar tendo mais de um revisor do Kubernetes para fornecer seu feedback ou você pode acabar obtendo feedback de um revisor do Kubernetes que é diferente daquele originalmente designado para lhe fornecer feedback. Além disso, em alguns casos, um de seus revisores pode solicitar uma revisão técnica de um [revisor de tecnologia Kubernetes](https://github.com/kubernetes/website/wiki/Tech-reviewers) quando necessário. Os revisores farão o melhor para fornecer feedback em tempo hábil, mas o tempo de resposta pode variar de acordo com as circunstâncias.
Para mais informações sobre como contribuir com a documentação do Kubernetes, consulte:
* [Comece a contribuir](https://kubernetes.io/docs/contribute/start/)
* [Preparando suas alterações na documentação](http://kubernetes.io/docs/contribute/intermediate#view-your-changes-locally)
* [Usando Modelos de Página](http://kubernetes.io/docs/contribute/style/page-templates/)
* [Guia de Estilo da Documentação](http://kubernetes.io/docs/contribute/style/style-guide/)
* [Localizando documentação do Kubernetes](https://kubernetes.io/docs/contribute/localization/)
## Documentação do Kubernetes Localizando o `README.md`
### coreano
Veja a tradução de `README.md` e mais orientações sobre detalhes para contribuidores coreanos na página [README coreano](README-ko.md).
Você pode alcançar os mantenedores da localização coreana em:
* June Yi ([GitHub - @gochist](https://github.com/gochist))
* [Slack channel](https://kubernetes.slack.com/messages/kubernetes-docs-ko)
## Executando o site localmente usando o Docker
A maneira recomendada de executar o site do Kubernetes localmente é executar uma imagem especializada do [Docker](https://docker.com) que inclui o gerador de site estático [Hugo](https://gohugo.io).
> Se você está rodando no Windows, você precisará de mais algumas ferramentas que você pode instalar com o [Chocolatey](https://chocolatey.org). `choco install make`
> Se você preferir executar o site localmente sem o Docker, consulte [Executando o site localmente usando o Hugo](#executando-o-site-localmente-usando-o-hugo) abaixo.
Se você tiver o Docker [em funcionamento](https://www.docker.com/get-started), crie a imagem do Docker do `kubernetes-hugo` localmente:
```bash
make docker-image
```
Depois que a imagem foi criada, você pode executar o site localmente:
```bash
make docker-serve
```
Abra seu navegador para http://localhost:1313 para visualizar o site. Conforme você faz alterações nos arquivos de origem, Hugo atualiza o site e força a atualização do navegador.
## Executando o site localmente usando o Hugo
Veja a [documentação oficial do Hugo](https://gohugo.io/getting-started/installing/) para instruções de instalação do Hugo. Certifique-se de instalar a versão do Hugo especificada pela variável de ambiente `HUGO_VERSION` no arquivo [`netlify.toml`](netlify.toml#L9).
Para executar o site localmente quando você tiver o Hugo instalado:
```bash
make serve
```
Isso iniciará o servidor Hugo local na porta 1313. Abra o navegador para http://localhost:1313 para visualizar o site. Conforme você faz alterações nos arquivos de origem, Hugo atualiza o site e força a atualização do navegador.
## Comunidade, discussão, contribuição e apoio
Aprenda a se envolver com a comunidade do Kubernetes na [página da comunidade](http://kubernetes.io/community/).
Você pode alcançar os mantenedores deste projeto em:
- [Slack](https://kubernetes.slack.com/messages/sig-docs)
- [Mailing List](https://groups.google.com/forum/#!forum/kubernetes-sig-docs)
### Código de conduta
A participação na comunidade Kubernetes é regida pelo [Código de Conduta da Kubernetes](code-of-conduct.md).
## Obrigado!
A Kubernetes prospera com a participação da comunidade e nós realmente apreciamos suas contribuições para o nosso site e nossa documentação!

40
README.md
View File

@ -3,13 +3,13 @@
[![Build Status](https://api.travis-ci.org/kubernetes/website.svg?branch=master)](https://travis-ci.org/kubernetes/website)
[![GitHub release](https://img.shields.io/github/release/kubernetes/website.svg)](https://github.com/kubernetes/website/releases/latest)
Welcome! This repository houses all of the assets required to build the [Kubernetes website and documentation](https://kubernetes.io/). We're very pleased that you want to contribute!
Welcome! This repository houses all of the assets required to build the [Kubernetes website and documentation](https://kubernetes.io/). We're glad that you want to contribute!
## Contributing to the docs
You can click the **Fork** button in the upper-right area of the screen to create a copy of this repository in your GitHub account. This copy is called a *fork*. Make any changes you want in your fork, and when you are ready to send those changes to us, go to your fork and create a new pull request to let us know about it.
Once your pull request is created, a Kubernetes reviewer will take responsibility for providing clear, actionable feedback. As the owner of the pull request, **it is your responsibility to modify your pull request to address the feedback that has been provided to you by the Kubernetes reviewer.** Also note that you may end up having more than one Kubernetes reviewer provide you feedback or you may end up getting feedback from a Kubernetes reviewer that is different than the one originally assigned to provide you feedback. Furthermore, in some cases, one of your reviewers might ask for a technical review from a [Kubernetes tech reviewer](https://github.com/kubernetes/website/wiki/Tech-reviewers) when needed. Reviewers will do their best to provide feedback in a timely fashion but response time can vary based on circumstances.
Once your pull request is created, a Kubernetes reviewer will take responsibility for providing clear, actionable feedback. As the owner of the pull request, **it is your responsibility to modify your pull request to address the feedback that has been provided to you by the Kubernetes reviewer.** Also, note that you may end up having more than one Kubernetes reviewer provide you feedback or you may end up getting feedback from a Kubernetes reviewer that is different than the one initially assigned to provide you feedback. Furthermore, in some cases, one of your reviewers might ask for a technical review from a [Kubernetes tech reviewer](https://github.com/kubernetes/website/wiki/Tech-reviewers) when needed. Reviewers will do their best to provide feedback in a timely fashion but response time can vary based on circumstances.
For more information about contributing to the Kubernetes documentation, see:
@ -19,24 +19,22 @@ For more information about contributing to the Kubernetes documentation, see:
* [Documentation Style Guide](http://kubernetes.io/docs/contribute/style/style-guide/)
* [Localizing Kubernetes Documentation](https://kubernetes.io/docs/contribute/localization/)
## `README.md`'s Localizing Kubernetes Documentation
## Localization `README.md`'s
| | |
|---|---|
|[French README](README-fr.md)|[Korean README](README-ko.md)|
|[German README](README-de.md)|[Portuguese README](README-pt.md)|
|[Hindi README](README-hi.md)|[Spanish README](README-es.md)|
|[Indonesian README](README-id.md)|
|||
### Korean
## Running the website locally using Docker
See translation of `README.md` and more detail guidance for Korean contributors on the [Korean README](README-ko.md) page.
You can reach the maintainers of Korean localization at:
* June Yi ([GitHub - @gochist](https://github.com/gochist))
* [Slack channel](https://kubernetes.slack.com/messages/kubernetes-docs-ko)
## Running the site locally using Docker
The recommended way to run the Kubernetes website locally is to run a specialized [Docker](https://docker.com) image that includes the [Hugo](https://gohugo.io) static site generator.
The recommended way to run the Kubernetes website locally is to run a specialized [Docker](https://docker.com) image that includes the [Hugo](https://gohugo.io) static website generator.
> If you are running on Windows, you'll need a few more tools which you can install with [Chocolatey](https://chocolatey.org). `choco install make`
> If you'd prefer to run the website locally without Docker, see [Running the site locally using Hugo](#running-the-site-locally-using-hugo) below.
> If you'd prefer to run the website locally without Docker, see [Running the website locally using Hugo](#running-the-site-locally-using-hugo) below.
If you have Docker [up and running](https://www.docker.com/get-started), build the `kubernetes-hugo` Docker image locally:
@ -44,25 +42,25 @@ If you have Docker [up and running](https://www.docker.com/get-started), build t
make docker-image
```
Once the image has been built, you can run the site locally:
Once the image has been built, you can run the website locally:
```bash
make docker-serve
```
Open up your browser to http://localhost:1313 to view the site. As you make changes to the source files, Hugo updates the site and forces a browser refresh.
Open up your browser to http://localhost:1313 to view the website. As you make changes to the source files, Hugo updates the website and forces a browser refresh.
## Running the site locally using Hugo
## Running the website locally using Hugo
See the [official Hugo documentation](https://gohugo.io/getting-started/installing/) for Hugo installation instructions. Make sure to install the Hugo version specified by the `HUGO_VERSION` environment variable in the [`netlify.toml`](netlify.toml#L9) file.
To run the site locally when you have Hugo installed:
To run the website locally when you have Hugo installed:
```bash
make serve
```
This will start the local Hugo server on port 1313. Open up your browser to http://localhost:1313 to view the site. As you make changes to the source files, Hugo updates the site and forces a browser refresh.
This will start the local Hugo server on port 1313. Open up your browser to http://localhost:1313 to view the website. As you make changes to the source files, Hugo updates the website and forces a browser refresh.
## Community, discussion, contribution, and support
@ -79,4 +77,4 @@ Participation in the Kubernetes community is governed by the [Kubernetes Code of
## Thank you!
Kubernetes thrives on community participation, and we really appreciate your contributions to our site and our documentation!
Kubernetes thrives on community participation, and we appreciate your contributions to our website and our documentation!

0
sass/OWNERS → assets/sass/OWNERS
View File

4
sass/_base.sass → assets/sass/_base.sass
View File

@ -580,6 +580,10 @@ section
#docs
#hero
&.light-text.no-sub
padding-bottom: 0px
#vendorStrip
line-height: 44px
max-width: 100%

0
sass/_case-studies.sass → assets/sass/_case-studies.sass
View File

0
sass/_desktop.sass → assets/sass/_desktop.sass
View File

0
sass/_reset.sass → assets/sass/_reset.sass
View File

0
sass/_size.sass → assets/sass/_size.sass
View File

0
sass/_skin.sass → assets/sass/_skin.sass
View File

0
sass/_tablet.sass → assets/sass/_tablet.sass
View File

6
sass/case-study-styles.sass → assets/sass/style.sass Normal file → Executable file
View File

@ -1,9 +1,11 @@
@import "reset"
@import "skin"
// media queries
@import "base"
@import "case-studies"
@import "tablet"
@import "desktop"
{{ if .Params.case_study_styles }}
@import "case-studies"
{{ end }}

43
config.toml
View File

@ -212,3 +212,46 @@ contentDir = "content/de"
time_format_blog = "02.01.2006"
# A list of language codes to look for untranslated content, ordered from left to right.
language_alternatives = ["en"]
[languages.es]
title = "Kubernetes"
description = "Production-Grade Container Orchestration"
languageName ="Español"
weight = 9
contentDir = "content/es"
[languages.es.params]
time_format_blog = "02.01.2006"
# A list of language codes to look for untranslated content, ordered from left to right.
language_alternatives = ["en"]
[languages.pt]
title = "Kubernetes"
description = "Orquestração de contêineres em nível de produção"
languageName ="Português"
weight = 9
contentDir = "content/pt"
[languages.pt.params]
time_format_blog = "02.01.2006"
# A list of language codes to look for untranslated content, ordered from left to right.
language_alternatives = ["en"]
[languages.id]
title = "Kubernetes"
description = "Production-Grade Container Orchestration"
languageName ="Bahasa Indonesia"
weight = 10
contentDir = "content/id"
[languages.id.params]
time_format_blog = "02.01.2006"
# A list of language codes to look for untranslated content, ordered from left to right.
language_alternatives = ["en"]
[languages.hi]
title = "Kubernetes"
description = "Production-Grade Container Orchestration"
languageName ="Hindi"
weight = 11
contentDir = "content/hi"

2
content/de/_index.html
View File

@ -44,7 +44,7 @@ Kubernetes ist Open Source und bietet Ihnen die Freiheit, die Infrastruktur vor
<br>
<br>
<br>
<a href="https://events.linuxfoundation.org/events/kubecon-cloudnativecon-europe-2019" button id="desktopKCButton">KubeCon am 20. und 23. Mai 2019 in Barcelona</a>
<a href="https://events.linuxfoundation.org/events/kubecon-cloudnativecon-europe-2019" button id="desktopKCButton">KubeCon vom 20-23. Mai 2019 in Barcelona</a>
<br>
<br>
<br>

10
content/de/blog/_index.md Normal file
View File

@ -0,0 +1,10 @@
---
title: Kubernetes Blog
linkTitle: Blog
menu:
main:
title: "Blog"
weight: 40
post: >
<p>Lesen Sie die neuesten Nachrichten über Kubernetes und das Containeruniversum im Allgemeinen. Erhalten Sie druckfrisch die neuesten Tutorials und technische Anleitungen.</p>
---

61
content/de/community/_index.html Normal file
View File

@ -0,0 +1,61 @@
---
title: Community
layout: basic
cid: community
---
<section id="mainContent">
<main>
<div class="content">
<h3>Die Gewissheit, dass Kubernetes überall und für alle gut funktioniert.</h3>
<p>Verbinden Sie sich mit der Kubernetes-Community in unserem <a href="http://slack.k8s.io/">Slack Kanal</a>, <a href="https://discuss.kubernetes.io/">Diskussionsforum</a>, oder beteiligen Sie sich an der <a href="https://groups.google.com/forum/#!forum/kubernetes-dev"> Kubernetes-dev-Google-Gruppe</a>. Eine wöchentliches Community-Meeting findet per Videokonferenz statt, um den Stand der Dinge zu diskutieren, folgen Sie
<a href="https://github.com/kubernetes/community/blob/master/events/community-meeting.md">diesen Anweisungen</a> für Informationen wie Sie teilnehmen können.</p>
<p>Sie können Kubernetes auch auf der ganzen Welt über unsere
<a href="https://www.meetup.com/topics/kubernetes/">Kubernetes Meetup Community</a> und der
<a href="https://www.meetup.com/Kubernetes-Cloud-Native-Online-Meetup/">Kubernetes Cloud Native Meetup Community</a> beitreten.</p>
</div>
<div class="content">
<h3>Special Interest Groups (SIGs)</h3>
<p>Haben Sie ein besonderes Interesse daran, wie Kubernetes mit einer anderen Technologie arbeitet? Werfen Sie einen Blick auf unsere kontinuierlich wachsende
<a href="https://git.k8s.io/community/sig-list.md">Listen von SIGs</a>, von AWS und Openstack bis hin zu Big Data und Skalierbarkeit, es gibt einen Platz für Sie, an dem Sie mitwirken können, und Anweisungen zur Gründung einer neuen SIG finden, wenn Ihr besonderes Interesse (noch) nicht abgedeckt ist.
</p>
<p>Als Mitglied der Kubernetes-Community sind Sie herzlich eingeladen, an allen SIG-Treffen teilzunehmen, die Sie interessieren. Eine Registrierung ist nicht erforderlich.</p>
</div>
<div class="content">
<h3>Verhaltensregeln</h3>
<p>Die Kubernetes-Community schätzt Respekt und Inklusivität und setzt einen <a href="code-of-conduct/">Verhaltenskodex</a>
in allen Interaktionen durch. Wenn Sie einen Verstoß gegen den Verhaltenskodex bei einer Veranstaltung oder Sitzung,
in Slack oder in einem anderen Kommunikationsmechanismus feststellen, wenden Sie sich
bitte an das <a href="https://github.com/kubernetes/community/tree/master/committee-code-of-conduct">Kubernetes Code of Conduct Committee</a> <a href="mailto:conduct@kubernetes.io">conduct@kubernetes.io</a>. Ihre Anonymität wird geschützt.
</p>
</div>
</main>
</section>
<section id="talkToUs">
<main>
<h3>Talk to Us!</h3>
<h4>Wir würden uns freuen, von Ihnen zu hören, wie Sie Kubernetes verwenden<br>und was wir tun können, um es besser zu machen.</h4>
<div id="bigSocial">
<div>
<a href="https://twitter.com/kubernetesio">@kubernetesio</a>
<p>Erhalten Sie die neuesten Nachrichten und Updates.</p>
</div>
<div>
<a href="https://github.com/kubernetes/kubernetes">Github Project</a>
<p>Informieren Sie sich über das Projekt und erwägen Sie, einen Beitrag zu leisten.</p>
</div>
<div>
<a href="http://slack.k8s.io/">#kubernetes-users</a>
<p>Unser Slack-Kanal ist der beste Weg, um unsere Ingenieure zu kontaktieren und Ihre Ideen mit ihnen zu teilen.</p>
</div>
<div>
<a href="http://stackoverflow.com/questions/tagged/kubernetes">Stack Overflow</a>
<p>Unser Benutzerforum ist ein großartiger Ort, um Community-Support zu erhalten.</p>
</div>
</div>
</main>
</section>

75
content/de/docs/concepts/_index.md Normal file
View File

@ -0,0 +1,75 @@
---
title: Konzepte
main_menu: true
content_template: templates/concept
weight: 40
---
{{% capture overview %}}
Im Abschnitt Konzepte erfahren Sie mehr über die Teile des Kubernetes-Systems und die Abstraktionen, die Kubernetes zur Darstellung Ihres Clusters verwendet, und Sie erhalten ein tieferes Verständnis der Funktionsweise von Kubernetes.
{{% /capture %}}
{{% capture body %}}
## Überblick
Um mit Kubernetes zu arbeiten, verwenden Sie *Kubernetes-API-Objekte*, um den *gewünschten Status Ihres Clusters* zu beschreiben:
welche Anwendungen oder anderen Workloads Sie ausführen möchten, welche Containerimages sie verwenden, die Anzahl der Replikate, welche Netzwerk- und Festplattenressourcen Sie zur Verfügung stellen möchten, und vieles mehr. Sie legen den gewünschten Status fest, indem Sie Objekte mithilfe der Kubernetes-API erstellen, normalerweise über die Befehlszeilenschnittstelle `kubectl`. Sie können die Kubernetes-API auch direkt verwenden, um mit dem Cluster zu interagieren und den gewünschten Status festzulegen oder zu ändern.
Sobald Sie den gewünschten Status eingestellt haben, wird das *Kubernetes Control Plane* dafür sorgen, dass der aktuelle Status des Clusters mit dem gewünschten Status übereinstimmt. Zu diesem Zweck führt Kubernetes verschiedene Aufgaben automatisch aus, z. B. Starten oder Neustarten von Containern, Skalieren der Anzahl der Repliken einer bestimmten Anwendung und vieles mehr. Das Kubernetes Control Plane besteht aus einer Reihe von Prozessen, die in Ihrem Cluster ausgeführt werden:
* Der **Kubernetes Master** bestehet aus drei Prozessen, die auf einem einzelnen Node in Ihrem Cluster ausgeführt werden, der als Master-Node bezeichnet wird. Diese Prozesse sind:[kube-apiserver](/docs/admin/kube-apiserver/), [kube-controller-manager](/docs/admin/kube-controller-manager/) und [kube-scheduler](/docs/admin/kube-scheduler/).
* Jeder einzelne Node in Ihrem Cluster, welcher nicht der Master ist, führt zwei Prozesse aus:
* **[kubelet](/docs/admin/kubelet/)**, das mit dem Kubernetes Master kommuniziert.
* **[kube-proxy](/docs/admin/kube-proxy/)**, ein Netzwerk-Proxy, der die Netzwerkdienste von Kubernetes auf jedem Node darstellt.
## Kubernetes Objects
Kubernetes enthält eine Reihe von Abstraktionen, die den Status Ihres Systems darstellen: implementierte containerisierte Anwendungen und Workloads, die zugehörigen Netzwerk- und Festplattenressourcen sowie weitere Informationen zu den Aufgaben Ihres Clusters. Diese Abstraktionen werden durch Objekte in der Kubernetes-API dargestellt; Lesen Sie [Kubernetes Objects Überblick](/docs/concepts/abstractions/overview/) für weitere Details.
Die grundlegenden Objekte von Kubernetes umfassen:
* [Pod](/docs/concepts/workloads/pods/pod-overview/)
* [Service](/docs/concepts/services-networking/service/)
* [Volume](/docs/concepts/storage/volumes/)
* [Namespace](/docs/concepts/overview/working-with-objects/namespaces/)
Darüber hinaus enthält Kubernetes eine Reihe von Abstraktionen auf höherer Ebene, die als Controller bezeichnet werden. Controller bauen auf den Basisobjekten auf und bieten zusätzliche Funktionen und Komfortfunktionen. Sie beinhalten:
* [ReplicaSet](/docs/concepts/workloads/controllers/replicaset/)
* [Deployment](/docs/concepts/workloads/controllers/deployment/)
* [StatefulSet](/docs/concepts/workloads/controllers/statefulset/)
* [DaemonSet](/docs/concepts/workloads/controllers/daemonset/)
* [Job](/docs/concepts/workloads/controllers/jobs-run-to-completion/)
## Kubernetes Control Plane
Die verschiedenen Teile der Kubernetes-Steuerungsebene (Control Plane), wie der Kubernetes Master- und der Kubelet-Prozess, bestimmen, wie Kubernetes mit Ihrem Cluster kommuniziert. Das Control Plane führt ein Inventar aller Kubernetes-Objekte im System und führt fortlaufende Steuerkreise aus, um den Status dieser Objekte zu verwalten. Zu jeder Zeit reagieren die Steuerkreise des Control Plane auf Änderungen im Cluster und arbeiten daran, dass der tatsächliche Status aller Objekte im System mit dem gewünschten Status, den Sie definiert haben, übereinstimmt.
Wenn Sie beispielsweise mit der Kubernetes-API ein Deployment-Objekt erstellen, geben Sie einen neuen gewünschten Status für das System an. Das Kubernetes Control Plane zeichnet die Objekterstellung auf und führt Ihre Anweisungen aus, indem es die erforderlichen Anwendungen startet und sie für auf den Cluster-Nodes plant--Dadurch wird der tatsächliche Status des Clusters an den gewünschten Status angepasst.
### Kubernetes Master
Der Kubernetes-Master ist für die Aufrechterhaltung des gewünschten Status für Ihren Cluster verantwortlich. Wenn Sie mit Kubernetes interagieren, beispielsweise mit dem Kommanduzeilen-Tool `kubectl`, kommunizieren Sie mit dem Kubernetes-Master Ihres Clusters.
> Der "Master" bezieht sich auf eine Reihe von Prozessen, die den Clusterstatus verwalten. Normalerweise werden diese Prozesse alle auf einem einzigen Node im Cluster ausgeführt. Dieser Node wird auch als Master bezeichnet. Der Master kann repliziert werden um Verfügbarkeit und Redundanz zu erhöhen.
### Kubernetes Nodes
Die Nodes in einem Cluster sind die Maschinen (VMs, physische Server usw.), auf denen Ihre Anwendungen und Cloud-Workflows ausgeführt werden. Der Kubernetes-Master steuert jeden Master. Sie werden selten direkt mit Nodes interagieren.
#### Objekt Metadata
* [Anmerkungen](/docs/concepts/overview/working-with-objects/annotations/)
{{% /capture %}}
{{% capture whatsnext %}}
Wenn Sie eine Konzeptseite schreiben möchten, lesen Sie [Seitenvorlagen verwenden](/docs/home/contribute/page-templates/)
für Informationen zum Konzeptseitentyp und zur Dokumentations Vorlage.
{{% /capture %}}

4
content/de/docs/concepts/architecture/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: "Kubernetes Architekur"
weight: 30
---

72
content/de/docs/concepts/architecture/master-node-communication.md Normal file
View File

@ -0,0 +1,72 @@
---
title: Master-Node Kommunikation
content_template: templates/concept
weight: 20
---
{{% capture overview %}}
Dieses Dokument katalogisiert die Kommunikationspfade zwischen dem Master (eigentlich dem Apiserver) und des Kubernetes-Clusters.
Die Absicht besteht darin, Benutzern die Möglichkeit zu geben, ihre Installation so anzupassen, dass die Netzwerkkonfiguration so abgesichert wird, dass der Cluster in einem nicht vertrauenswürdigen Netzwerk (oder mit vollständig öffentlichen IP-Adressen eines Cloud-Providers) ausgeführt werden kann.
{{% /capture %}}
{{% capture body %}}
## Cluster zum Master
Alle Kommunikationspfade vom Cluster zum Master enden beim Apiserver (keine der anderen Master-Komponenten ist dafür ausgelegt, Remote-Services verfügbar zu machen).
In einem typischen Setup ist der Apiserver so konfiguriert, dass er Remote-Verbindungen an einem sicheren HTTPS-Port (443) mit einer oder mehreren Formen der [Clientauthentifizierung](/docs/reference/access-authn-authz/authentication/) überwacht.
Eine oder mehrere Formene von [Autorisierung](/docs/reference/access-authn-authz/authorization/) sollte aktiviert sein, insbesondere wenn [anonyme Anfragen](/docs/reference/access-authn-authz/authentication/#anonymous-requests) oder [Service Account Tokens](/docs/reference/access-authn-authz/authentication/#service-account-tokens) aktiviert sind.
Nodes sollten mit dem öffentlichen Stammzertifikat für den Cluster konfigurirert werden, sodass sie eine sichere Verbindung zum Apiserver mit gültigen Client-Anmeldeinformationen herstellen können.
Beispielsweise bei einer gewöhnlichen GKE-Konfiguration enstprechen die dem kubelet zur Verfügung gestellten Client-Anmeldeinformationen eines Client-Zertifikats.
Lesen Sie über [kubelet TLS bootstrapping](/docs/reference/command-line-tools-reference/kubelet-tls-bootstrapping/) zur automatisierten Bereitstellung von kubelet-Client-Zertifikaten.
Pods, die eine Verbindung zum Apiserver herstellen möchten, können dies auf sichere Weise tun, indem sie ein Dienstkonto verwenden, sodass Kubernetes das öffentliche Stammzertifikat und ein gültiges Trägertoken automatisch in den Pod einfügt, wenn er instanziert wird.
Der `kubernetes`-Dienst (in allen Namespaces) ist mit einer virtuellen IP-Adresse konfiguriert, die (über den Kube-Proxy) an den HTTPS-Endpunkt auf dem Apiserver umgeleitet wird.
Die Master-Komponenten kommunizieren auch über den sicheren Port mit dem Cluster-Apiserver.
Der Standardbetriebsmodus für Verbindungen vom Cluster (Knoten und Pods, die auf den Knoten ausgeführt werden) zum Master ist daher standardmäßig gesichert und kann über nicht vertrauenswürdige und/oder öffentliche Netzwerke laufen.
## Master zum Cluster
Es gibt zwei primäre Kommunikationspfade vom Master (Apiserver) zum Cluster.
Der erste ist vom Apiserver bis zum Kubelet-Prozess, der auf jedem Node im Cluster ausgeführt wird.
Der zweite ist vom Apiserver zu einem beliebigen Node, Pod oder Dienst über die Proxy-Funktionalität des Apiservers.
### Apiserver zum kubelet
Die Verbindungen vom Apiserver zum Kubelet werden verwendet für:
* Abrufen von Protokollen für Pods.
* Verbinden (durch kubectl) mit laufenden Pods.
* Bereitstellung der Portweiterleitungsfunktion des kubelet.
Diese Verbindungen enden am HTTPS-Endpunkt des kubelet.
Standardmäßig überprüft der Apiserver das Serverzertifikat des Kubelet nicht, was die Verbindung von angreifbar für Man-in-the-Middle-Angriffe macht, und ist es ist daher **unsicher** wenn die Verbindungen über nicht vertrauenswürdige und/oder öffentliche Netzwerke laufen.
Um diese Verbindung zu überprüfen, verwenden Sie das Flag `--kubelet-certificate-authority`, um dem Apiserver ein Stammzertifikatbündel bereitzustellen, das zur Überprüfung des Server-Zertifikats des kubelet verwendet wird.
Wenn dies nicht möglich ist, verwenden Sie [SSH tunneling](/docs/concepts/architecture/master-node-communication/#ssh-tunnels)
zwischen dem Apiserver und kubelet, falls erforderlich, um eine Verbindung über ein nicht vertrauenswürdiges oder öffentliches Netz zu vermeiden.
Ausserdem sollte, [Kubelet Authentifizierung und/oder Autorisierung](/docs/admin/kubelet-authentication-authorization/) sollte aktiviert sein, um die kubelet-API zu sichern.
### Apiserver zu Nodes, Pods und Services
Die Verbindungen vom Apiserver zu einem Node, Pod oder Dienst verwenden standardmäßig einfache HTTP-Verbindungen und werden daher weder authentifiziert noch verschlüsselt.
Sie können über eine sichere HTTPS-Verbindung ausgeführt werden, indem dem Node, dem Pod oder dem Servicenamen in der API-URL "https:" vorangestellt wird. Das vom HTTPS-Endpunkt bereitgestellte Zertifikat wird jedoch nicht überprüft, und es werden keine Clientanmeldeinformationen bereitgestellt. Die Verbindung wird zwar verschlüsselt, garantiert jedoch keine Integrität.
Diese Verbindungen **sind derzeit nicht sicher** innerhalb von nicht vertrauenswürdigen und/oder öffentlichen Netzen.
### SSH Tunnels
Kubernetes unterstützt SSH-Tunnel zum Schutz der Kommunikationspfade von Master -> Cluster.
In dieser Konfiguration initiiert der Apiserver einen SSH-Tunnel zu jedem Nodem im Cluster (Verbindung mit dem SSH-Server, der Port 22 läuft), und leitet den gesamten Datenverkehr für ein kubelet, einen Node, einen Pod oder einen Dienst durch den Tunnel.
Dieser Tunnel stellt sicher, dass der Datenverkehr nicht außerhalb des Netzwerks sichtbar ist, in dem die Knoten ausgeführt werden.
SSH-Tunnel sind derzeit nicht mehr unterstützt. Sie sollten sie also nicht verwenden, es sei denn, Sie wissen, was Sie tun. Ein Ersatz für diesen Kommunikationskanal wird entwickelt.
{{% /capture %}}

247
content/de/docs/concepts/architecture/nodes.md Normal file
View File

@ -0,0 +1,247 @@
---
title: Nodes
content_template: templates/concept
weight: 10
---
{{% capture overview %}}
Ein Knoten (Node in Englisch) ist eine Arbeitsmaschine in Kubernetes, früher als `minion` bekannt. Ein Node
kann je nach Cluster eine VM oder eine physische Maschine sein. Jeder Node enthält
die für den Betrieb von [Pods](/docs/concepts/workloads/pods/pod/) notwendigen Dienste
und wird von den Master-Komponenten verwaltet.
Die Dienste auf einem Node umfassen die [Container Runtime](/docs/concepts/overview/components/#node-components), das Kubelet und den Kube-Proxy.
Weitere Informationen finden Sie im Abschnitt Kubernetes Node in der Architekturdesign-Dokumentation.
{{% /capture %}}
{{% capture body %}}
## Node Status
Der Status eines Nodes enthält folgende Informationen:
* [Adressen](#adressen)
* [Zustand](#zustand)
* [Kapazität](#kapazität)
* [Info](#info)
Jeder Abschnitt wird folgend detailliert beschrieben.
### Adressen
Die Verwendung dieser Felder hängt von Ihrem Cloud-Anbieter oder der Bare-Metal-Konfiguration ab.
* HostName: Der vom Kernel des Nodes gemeldete Hostname. Kann mit dem kubelet-Parameter `--hostname-override` überschrieben werden.
* ExternalIP: In der Regel die IP-Adresse des Nodes, die extern geroutet werden kann (von außerhalb des Clusters verfügbar).
* InternalIP: In der Regel die IP-Adresse des Nodes, die nur innerhalb des Clusters routbar ist.
### Zustand
Das `conditions` Feld beschreibt den Zustand, aller `Running` Nodes.
| Node Condition | Beschreibung |
|----------------|-------------|
| `OutOfDisk` | `True` wenn auf dem Node nicht genügend freier Speicherplatz zum Hinzufügen neuer Pods vorhanden ist, andernfalls `False` |
| `Ready` | `True` wenn der Node in einem guten Zustand und bereit ist Pods aufzunehmen, `False` wenn der Node nicht in einem guten Zustand ist und nicht bereit ist Pods aufzunehmeb, und `Unknown` wenn der Node-Controller seit der letzten `node-monitor-grace-period` nichts von dem Node gehört hat (Die Standardeinstellung beträgt 40 Sekunden) |
| `MemoryPressure` | `True` wenn der verfügbare Speicher des Nodes niedrig ist; Andernfalls`False` |
| `PIDPressure` | `True` wenn zu viele Prozesse auf dem Node vorhanden sind; Andernfalls`False` |
| `DiskPressure` | `True` wenn die Festplattenkapazität niedrig ist. Andernfalls `False` |
| `NetworkUnavailable` | `True` wenn das Netzwerk für den Node nicht korrekt konfiguriert ist, andernfalls `False` |
Der Zustand eines Nodes wird als JSON-Objekt dargestellt. Die folgende Antwort beschreibt beispielsweise einen fehlerfreien Node.
```json
"conditions": [
{
"type": "Ready",
"status": "True"
}
]
```
Wenn der Status der `Ready`-Bedingung `Unknown` oder `False` länger als der `pod-eviction-timeout` bleibt, wird ein Parameter an den [kube-controller-manager](/docs/admin/kube-controller-manager/) übergeben und alle Pods auf dem Node werden vom Node Controller gelöscht.
Die voreingestellte Zeit vor der Entfernung beträgt **fünf Minuten**.
In einigen Fällen, in denen der Node nicht erreichbar ist, kann der Apiserver nicht mit dem Kubelet auf dem Node kommunizieren.
Die Entscheidung, die Pods zu löschen, kann dem Kublet erst mitgeteilt werden, wenn die Kommunikation mit dem Apiserver wiederhergestellt ist.
In der Zwischenzeit können Pods, deren Löschen geplant ist, weiterhin auf dem unzugänglichen Node laufen.
In Versionen von Kubernetes vor 1.5 würde der Node Controller das Löschen dieser unerreichbaren Pods vom Apiserver [erzwingen](/docs/concepts/workloads/pods/pod/#force-deletion-of-pods). In Version 1.5 und höher erzwingt der Node Controller jedoch keine Pod Löschung, bis bestätigt wird, dass sie nicht mehr im Cluster ausgeführt werden. Pods die auf einem unzugänglichen Node laufen sind eventuell in einem einem `Terminating` oder `Unkown` Status. In Fällen, in denen Kubernetes nicht aus der zugrunde liegenden Infrastruktur schließen kann, ob ein Node einen Cluster dauerhaft verlassen hat, muss der Clusteradministrator den Node möglicherweise manuell löschen.
Das Löschen des Kubernetes-Nodeobjekts bewirkt, dass alle auf dem Node ausgeführten Pod-Objekte gelöscht und deren Namen freigegeben werden.
In Version 1.12 wurde die Funktion `TaintNodesByCondition` als Beta-Version eingeführt, die es dem Node-Lebenszyklus-Controller ermöglicht, automatisch [Markierungen](/docs/concepts/configuration/taint-and-toleration/) (*taints* in Englisch) zu erstellen, die Bedingungen darstellen.
Ebenso ignoriert der Scheduler die Bedingungen, wenn er einen Node berücksichtigt; stattdessen betrachtet er die Markierungen (taints) des Nodes und die Toleranzen eines Pod.
Anwender können jetzt zwischen dem alten Scheduling-Modell und einem neuen, flexibleren Scheduling-Modell wählen.
Ein Pod, der keine Toleranzen aufweist, wird gemäß dem alten Modell geplant.
Aber ein Pod, die die Taints eines bestimmten Node toleriert, kann auf diesem Node geplant werden.
{{< caution >}}
Wenn Sie diese Funktion aktivieren, entsteht eine kleine Verzögerung zwischen der Zeit,
in der eine Bedingung beobachtet wird, und der Zeit, in der ein Taint entsteht.
Diese Verzögerung ist in der Regel kürzer als eine Sekunde, aber sie kann die Anzahl
der Pods erhöhen, die erfolgreich geplant, aber vom Kubelet abgelehnt werden.
{{< /caution >}}
### Kapazität
Beschreibt die auf dem Node verfügbaren Ressourcen: CPU, Speicher und die maximale
Anzahl der Pods, die auf dem Node ausgeführt werden können.
### Info
Allgemeine Informationen zum Node, z. B. Kernelversion, Kubernetes-Version
(kubelet- und kube-Proxy-Version), Docker-Version (falls verwendet), Betriebssystemname.
Die Informationen werden von Kubelet vom Node gesammelt.
## Management
Im Gegensatz zu [Pods](/docs/concepts/workloads/pods/pod/) und [Services](/docs/concepts/services-networking/service/),
ein Node wird nicht von Kubernetes erstellt: Er wird extern von Cloud-Anbietern wie Google Compute Engine erstellt oder ist in Ihrem Pool physischer oder virtueller Maschinen vorhanden.
Wenn Kubernetes also einen Node erstellt, wird ein Objekt erstellt, das den Node darstellt.
Nach der Erstellung überprüft Kubernetes, ob der Node gültig ist oder nicht.
Wenn Sie beispielsweise versuchen, einen Node aus folgendem Inhalt zu erstellen:
```json
{
"kind": "Node",
"apiVersion": "v1",
"metadata": {
"name": "10.240.79.157",
"labels": {
"name": "my-first-k8s-node"
}
}
}
```
Kubernetes erstellt intern ein Node-Oject (die Darstellung) und validiert den Node durch Zustandsprüfung basierend auf dem Feld `metadata.name`.
Wenn der Node gültig ist, d.h. wenn alle notwendigen Dienste ausgeführt werden, ist er berechtigt, einen Pod auszuführen.
Andernfalls wird er für alle Clusteraktivitäten ignoriert, bis er gültig wird.
{{< note >}}
Kubernetes behält das Objekt für den ungültigen Node und prüft ständig seine Gültigkeit.
Sie müssen das Node-Objekt explizit löschen, um diesen Prozess zu stoppen.
{{< /note >}}
Aktuell gibt es drei Komponenten, die mit dem Kubernetes Node-Interface interagieren: Node Controller, Kubelet und Kubectl.
### Node Controller
Der Node Controller ist eine Kubernetes-Master-Komponente, die verschiedene Aspekte von Nodes verwaltet.
Der Node Controller hat mehrere Rollen im Leben eines Nodes.
Der erste ist die Zuordnung eines CIDR-Blocks zu dem Node, wenn er registriert ist (sofern die CIDR-Zuweisung aktiviert ist).
Die zweite ist, die interne Node-Liste des Node Controllers mit der Liste der verfügbaren Computer des Cloud-Anbieters auf dem neuesten Stand zu halten.
Wenn ein Node in einer Cloud-Umgebung ausgeführt wird und sich in einem schlechten Zustand befindet, fragt der Node Controller den Cloud-Anbieter, ob die virtuelle Maschine für diesen Node noch verfügbar ist. Wenn nicht, löscht der Node Controller den Node aus seiner Node-Liste.
Der dritte ist die Überwachung des Zustands der Nodes. Der Node Controller ist dafür verantwortlich,
die NodeReady-Bedingung von NodeStatus auf ConditionUnknown zu aktualisieren, wenn ein wenn ein Node unerreichbar wird (der Node Controller empfängt aus irgendeinem Grund keine Herzschläge mehr, z.B. weil der Node heruntergefahren ist) und später alle Pods aus dem Node zu entfernen (und diese ordnungsgemäss zu beenden), wenn der Node weiterhin unzugänglich ist. (Die Standard-Timeouts sind 40s, um ConditionUnknown zu melden und 5 Minuten, um mit der Evakuierung der Pods zu beginnen).
Der Node Controller überprüft den Zustand jedes Nodes alle `--node-monitor-period` Sekunden.
In Versionen von Kubernetes vor 1.13 ist NodeStatus der Herzschlag des Nodes.
Ab Kubernetes 1.13 wird das Node-Lease-Feature als Alpha-Feature eingeführt (Feature-Gate `NodeLease`, [KEP-0009](https://github.com/kubernetes/community/blob/master/keps/sig-node/0009-node-heartbeat.md)).
Wenn die Node Lease Funktion aktiviert ist, hat jeder Node ein zugeordnetes `Lease`-Objekt im `kube-node-lease`-Namespace, das vom Node regelmäßig erneuert wird.
Sowohl NodeStatus als auch Node Lease werden als Herzschläge vom Node aus behandelt.
Node Leases werden häufig erneuert, während NodeStatus nur dann vom Node zu Master gemeldet wird, wenn sich etwas ändert oder genügend Zeit vergangen ist (Standard ist 1 Minute, was länger ist als der Standard-Timeout von 40 Sekunden für unerreichbare Nodes).
Da Node Leases viel lastärmer sind als NodeStatus, macht diese Funktion den Node Herzschlag sowohl in Bezug auf Skalierbarkeit als auch auf die Leistung deutlich effizienter.
In Kubernetes 1.4 haben wir die Logik der Node-Steuerung aktualisiert, um Fälle besser zu handhaben, in denen eine große Anzahl von Nodes Probleme hat, den Master zu erreichen (z.B. weil der Master Netzwerkprobleme hat).
Ab 1.4 betrachtet der Node-Controller den Zustand aller Nodes im Cluster, wenn er eine Entscheidung über die Enterfung eines Pods trifft.
In den meisten Fällen begrenzt der Node-Controller die Entfernungsrate auf `--node-eviction-rate` (Standard 0,1) pro Sekunde, was bedeutet, dass er die Pods nicht von mehr als einem Node pro 10 Sekunden entfernt.
Das Entfernungsverhalten von Nodes ändert sich, wenn ein Node in einer bestimmten Verfügbarkeitszone ungesund wird.
Der Node-Controller überprüft gleichzeitig, wie viel Prozent der Nodes in der Zone ungesund sind (NodeReady-Bedingung ist ConditionUnknown oder ConditionFalse).
Wenn der Anteil der ungesunden Nodes mindestens `--unhealthy-zone-threshold` (Standard 0,55) beträgt, wird die Entfernungsrate reduziert:
Wenn der Cluster klein ist (d.h. weniger als oder gleich `--large-cluster-size-threshold` Node - Standard 50), werden die Entfernungen gestoppt. Andernfalls wird die Entfernungsrate auf `--secondary-node-eviction-rate` (Standard 0,01) pro Sekunde reduziert.
Der Grund, warum diese Richtlinien pro Verfügbarkeitszone implementiert werden, liegt darin, dass eine Verfügbarkeitszone vom Master unerreichbar werden könnte, während die anderen verbunden bleiben. Wenn Ihr Cluster nicht mehrere Verfügbarkeitszonen von Cloud-Anbietern umfasst, gibt es nur eine Verfügbarkeitszone (den gesamten Cluster).
Ein wichtiger Grund für die Verteilung Ihrer Nodes auf Verfügbarkeitszonen ist, dass die Arbeitsbelastung auf gesunde Zonen verlagert werden kann, wenn eine ganze Zone ausfällt.
Wenn also alle Nodes in einer Zone ungesund sind, entfernt Node Controller mit der normalen `--node-eviction-rate` Geschwindigkeit.
Der Ausnahmefall ist, wenn alle Zonen völlig ungesund sind (d.h. es gibt keine gesunden Node im Cluster).
In diesem Fall geht der Node-Controller davon aus, dass es ein Problem mit der Master-Konnektivität gibt und stoppt alle Entfernungen, bis die Verbindung wiederhergestellt ist.
Ab Kubernetes 1.6 ist der Node-Controller auch für die Entfernung von Pods zuständig, die auf Nodes mit `NoExecute`-Taints laufen, wenn die Pods die Markierungen nicht tolerieren.
Zusätzlich ist der NodeController als Alpha-Funktion, die standardmäßig deaktiviert ist, dafür verantwortlich, Taints hinzuzufügen, die Node Probleme, wie `Node unreachable` oder `not ready` entsprechen.
Siehe [diese Dokumentation](/docs/concepts/configuration/taint-and-toleration/) für Details über `NoExecute` Taints und die Alpha-Funktion.
Ab Version 1.8 kann der Node-Controller für die Erzeugung von Taints, die Node Bedingungen darstellen, verantwortlich gemacht werden. Dies ist eine Alpha-Funktion der Version 1.8.
### Selbstregistrierung von Nodes
Wenn das Kubelet-Flag `--register-node` aktiv ist (Standard), versucht das Kubelet, sich beim API-Server zu registrieren. Dies ist das bevorzugte Muster, das von den meisten Distributionen verwendet wird.
Zur Selbstregistrierung wird das kubelet mit den folgenden Optionen gestartet:
- `--kubeconfig` - Pfad zu Anmeldeinformationen, um sich beim Apiserver zu authentifizieren.
- `--cloud-provider` - Wie man sich mit einem Cloud-Anbieter unterhält, um Metadaten über sich selbst zu lesen.
- `--register-node` - Automatisch beim API-Server registrieren.
- `--register-with-taints` - Registrieren Sie den Node mit der angegebenen Taints-Liste (Kommagetrennt `<key>=<value>:<effect>`). No-op wenn `register-node` false ist.
- `--node-ip` - IP-Adresse des Nodes.
- `--node-labels` - Labels, die bei der Registrierung des Nodes im Cluster hinzugefügt werden sollen (Beachten Sie die Richlinien des [NodeRestriction admission plugin](/docs/reference/access-authn-authz/admission-controllers/#noderestriction) in 1.13+).
- `--node-status-update-frequency` - Gibt an, wie oft kubelet den Nodestatus an den Master übermittelt.
Wenn der [Node authorization mode](/docs/reference/access-authn-authz/node/) und
[NodeRestriction admission plugin](/docs/reference/access-authn-authz/admission-controllers/#noderestriction) aktiviert sind,
dürfen kubelets nur ihre eigene Node-Ressource erstellen / ändern.
#### Manuelle Nodeverwaltung
Ein Cluster-Administrator kann Nodeobjekte erstellen und ändern.
Wenn der Administrator Nodeobjekte manuell erstellen möchte, setzen Sie das kubelet Flag `--register-node=false`.
Der Administrator kann Node-Ressourcen ändern (unabhängig von der Einstellung von `--register-node`).
Zu den Änderungen gehören das Setzen von Labels und das Markieren des Nodes.
Labels auf Nodes können in Verbindung mit node selectors auf Pods verwendet werden, um die Planung zu steuern, z.B. um einen Pod so zu beschränken, dass er nur auf einer Teilmenge der Nodes ausgeführt werden darf.
Das Markieren eines Nodes als nicht geplant, verhindert, dass neue Pods für diesen Node geplant werden. Dies hat jedoch keine Auswirkungen auf vorhandene Pods auf dem Node.
Dies ist nützlich als vorbereitender Schritt vor einem Neustart eines Nodes usw.
Um beispielsweise einen Node als nicht geplant zu markieren, führen Sie den folgenden Befehl aus:
```shell
kubectl cordon $NODENAME
```
{{< note >}}
Pods, die von einem DaemonSet-Controller erstellt wurden, umgehen den Kubernetes-Scheduler und respektieren nicht das _unschedulable_ Attribut auf einem Node.
Dies setzt voraus, dass Daemons auf dem Computer verbleiben, auch wenn während der Vorbereitung eines Neustarts keine Anwendungen mehr vorhanden sind.
{{< /note >}}
### Node Kapazität
Die Kapazität des Nodes (Anzahl der CPU und Speichermenge) ist Teil des Nodeobjekts.
Normalerweise registrieren sich Nodes selbst und melden ihre Kapazität beim Erstellen des Nodeobjekts.
Sofern Sie [Manuelle Nodeverwaltung](#Manuelle-Nodeverwaltung) betreiben, müssen Sie die Node Kapazität setzen, wenn Sie einen Node hinzufügen.
Der Kubernetes-Scheduler stellt sicher, dass für alle Pods auf einem Nodes genügend Ressourcen vorhanden sind.
Er prüft, dass die Summe der Requests von Containern auf dem Node nicht größer ist als die Kapazität des Nodes.
Er beinhaltet alle Container die vom kubelet gestarted worden, aber keine Container die direkt von der [container runtime](/docs/concepts/overview/components/#node-components) gestartet wurden, noch jegleiche Prozesse die ausserhalb von Containern laufen.
Wenn Sie Ressourcen explizit für Nicht-Pod-Prozesse reservieren möchten, folgen Sie diesem Lernprogramm um [Ressourcen für Systemdaemons zu reservieren](/docs/tasks/administer-cluster/reserve-compute-resources/#system-reserved).
## API-Objekt
Node ist eine Top-Level-Ressource in der Kubernetes-REST-API. Weitere Details zum API-Objekt finden Sie unter:
[Node API object](/docs/reference/generated/kubernetes-api/{{< param "version" >}}/#node-v1-core).
{{% /capture %}}

5
content/de/docs/concepts/cluster-administration/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Cluster Administration"
weight: 100
---

5
content/de/docs/concepts/configuration/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Konfiguration"
weight: 80
---

5
content/de/docs/concepts/containers/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Container"
weight: 40
---

38
content/de/docs/concepts/example-concept-template.md Normal file
View File

@ -0,0 +1,38 @@
---
title: Konzept Dokumentations-Vorlage
content_template: templates/concept
toc_hide: true
---
{{% capture overview %}}
{{< note >}}
Stellen Sie auch sicher [einen Eintrag im Inhaltsverzeichnis](/docs/home/contribute/write-new-topic/#creating-an-entry-in-the-table-of-contents) für Ihr neues Dokument zu erstellen.
{{< /note >}}
Diese Seite erklärt ...
{{% /capture %}}
{{% capture body %}}
## Verstehen ...
Kubernetes bietet ...
## Verwenden ...
Benutzen Sie ...
{{% /capture %}}
{{% capture whatsnext %}}
**[Optionaler Bereich]**
* Lernen Sie mehr über [ein neues Thema schreiben](/docs/home/contribute/write-new-topic/).
* Besuchen Sie [Seitenvorlagen verwenden - Konzeptvorlage](/docs/home/contribute/page-templates/#concept_template) wie Sie diese Vorlage verwenden.
{{% /capture %}}

4
content/de/docs/concepts/extend-kubernetes/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: "Kubernets erweitern"
weight: 110
---

5
content/de/docs/concepts/overview/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Überblick"
weight: 20
---

112
content/de/docs/concepts/overview/components.md Normal file
View File

@ -0,0 +1,112 @@
---
title: Kubernetes Komponenten
content_template: templates/concept
weight: 20
card:
name: concepts
weight: 20
---
{{% capture overview %}}
In diesem Dokument werden die verschiedenen binären Komponenten beschrieben, die zur Bereitstellung eines funktionsfähigen Kubernetes-Clusters erforderlich sind.
{{% /capture %}}
{{% capture body %}}
## Master-Komponenten
Master-Komponenten stellen die Steuerungsebene des Clusters bereit. Master-Komponenten treffen globale Entscheidungen über den Cluster (z. B. Zeitplanung) und das Erkennen und Reagieren auf Clusterereignisse (Starten eines neuen Pods, wenn das `replicas`-Feld eines Replikationscontrollers nicht zufriedenstellend ist).
Master-Komponenten können auf jedem Computer im Cluster ausgeführt werden.
Der Einfachheit halber starten Setup-Skripts normalerweise alle Master-Komponenten auf demselben Computer, und es werden keine Benutzercontainer auf diesem Computer ausgeführt.
Lesen Sie [Cluster mit hoher Verfügbarkeit erstellen](/docs/admin/high-availability/) für ein Beispiel für ein Multi-Master-VM-Setup.
### kube-apiserver
{{< glossary_definition term_id="kube-apiserver" length="all" >}}
### etcd
{{< glossary_definition term_id="etcd" length="all" >}}
### kube-scheduler
{{< glossary_definition term_id="kube-scheduler" length="all" >}}
### kube-controller-manager
{{< glossary_definition term_id="kube-controller-manager" length="all" >}}
Diese Controller umfassen:
* Node Controller: Verantwortlich für das Erkennen und Reagieren, wenn Nodes ausfallen.
* Replication Controller: Verantwortlich für die Aufrechterhaltung der korrekten Anzahl von Pods für jedes Replikationscontrollerobjekt im System.
* Endpoints Controller: Füllt das Endpoints-Objekt aus (d.h. verbindet Services & Pods).
* Service Account & Token Controllers: Erstellt Standardkonten und API-Zugriffstoken für neue Namespaces.
### cloud-controller-manager
[cloud-controller-manager](/docs/tasks/administer-cluster/running-cloud-controller/) führt Controller aus, die mit den entsprechenden Cloud-Anbietern interagieren.
Der cloud-controller-manager ist eine Alpha-Funktion, die in Kubernetes Version 1.6 eingeführt wurde.
cloud-controller-manager führt nur Cloud-Provider-spezifische Controller-Schleifen aus. Sie müssen diese Controller-Schleifen im Cube-Controller-Manager deaktivieren. Sie können die Controller-Schleifen deaktivieren, indem Sie beim Starten des kube-controller-manager das Flag `--cloud-provider` auf `external` setzen.
cloud-controller-manager erlaubt es dem Cloud-Anbieter Code und dem Kubernetes-Code, sich unabhängig voneinander zu entwickeln.
In früheren Versionen war der Kerncode von Kubernetes für die Funktionalität von Cloud-Provider-spezifischem Code abhängig.
In zukünftigen Versionen sollte der für Cloud-Anbieter spezifische Code vom Cloud-Anbieter selbst verwaltet und mit dem Cloud-Controller-Manager verknüpft werden, während Kubernetes ausgeführt wird.
Die folgenden Controller haben Abhängigkeiten von Cloud-Anbietern:
* Node Controller: Zum Überprüfen, ob ein Node in der Cloud beim Cloud-Anbieter gelöscht wurde, nachdem er nicht mehr reagiert
* Route Controller: Zum Einrichten von Routen in der zugrunde liegenden Cloud-Infrastruktur
* Service Controller: Zum Erstellen, Aktualisieren und Löschen von Lastverteilern von Cloud-Anbietern
* Volume Controller: Zum Erstellen, Verbinden und Bereitstellen von Volumes und zur Interaktion mit dem Cloud-Provider zum Orchestrieren von Volumes
## Node-Komponenten
Node Komponenten werden auf jedem Knoten ausgeführt, halten laufende Pods aufrecht und stellen die Kubernetes-Laufzeitumgebung bereit.
### kubelet
{{< glossary_definition term_id="kubelet" length="all" >}}
### kube-proxy
[kube-proxy](/docs/admin/kube-proxy/) ermöglicht die Kubernetes Service-Abstraktion, indem die Netzwerkregeln auf dem Host beibehalten und die Verbindungsweiterleitung durchgeführt wird.
### Container Runtime
Die Containerlaufzeit ist die Software, die für das Ausführen von Containern verantwortlich ist.
Kubernetes unterstützt mehrere Laufzeiten: [Docker](http://www.docker.com), [containerd](https://containerd.io), [cri-o](https://cri-o.io/), [rktlet](https://github.com/kubernetes-incubator/rktlet) und jede Implementierung des [Kubernetes CRI (Container Runtime Interface)](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-node/container-runtime-interface.md).
## Addons
Addons sind Pods und Dienste, die Clusterfunktionen implementieren. Die Pods können verwaltet werden
durch Deployments, ReplicationControllers, und so wieter.
Namespace-Addon-Objekte werden im Namespace `kube-system` erstellt.
Ausgewählte Addons werden unten beschrieben. Eine erweiterte Liste verfügbarer Addons finden Sie unter [Addons](/docs/concepts/cluster-administration/addons/).
### DNS
Während die anderen Addons nicht unbedingt erforderlich sind, sollte [cluster DNS](/docs/concepts/services-networking/dns-pod-service/) in allen Kubernetes-Cluster vorhanden sein, da viele Beispiele davon abhängen.
Cluster-DNS ist neben anderen DNS-Servern in Ihrer Umgebung ein DNS-Server, der DNS-Einträge für Kubernetes-Dienste bereitstellt.
Von Kubernetes gestartete Container schließen diesen DNS-Server automatisch in ihre DNS-Suchen ein.
### Web UI (Dashboard)
[Dashboard](/docs/tasks/access-application-cluster/web-ui-dashboard/) ist eine allgemeine, webbasierte Benutzeroberfläche für Kubernetes-Cluster. Benutzer können damit Anwendungen, die im Cluster ausgeführt werden, sowie den Cluster selbst verwalten und Fehler beheben.
### Container Resource Monitoring
[Container Resource Monitoring](/docs/tasks/debug-application-cluster/resource-usage-monitoring/) zeichnet generische Zeitreihenmessdaten zu Containern in einer zentralen Datenbank auf und stellt eine Benutzeroberfläche zum Durchsuchen dieser Daten bereit.
### Cluster-level Logging
Ein [Cluster-level logging](/docs/concepts/cluster-administration/logging/) Mechanismus ist für das Speichern von Containerprotokollen in einem zentralen Protokollspeicher mit Such- / Browsing-Schnittstelle verantwortlich.
{{% /capture %}}

5
content/de/docs/concepts/policy/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Richtlinien"
weight: 90
---

5
content/de/docs/concepts/services-networking/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Dienste, Lastverteilung und Netzwerkfunktionen"
weight: 60
---

5
content/de/docs/concepts/storage/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Speicher"
weight: 70
---

5
content/de/docs/concepts/workloads/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: "Workloads"
weight: 50
---

62
content/de/docs/contribute/_index.md Normal file
View File

@ -0,0 +1,62 @@
---
content_template: templates/concept
title: Zur Kubernets-Dokumentation beitragen
linktitle: Mitmachen
main_menu: true
weight: 80
---
{{% capture overview %}}
Wenn Sie an der Dokumentation oder der Website von Kubernetes mitwirken möchten, freuen wir uns über Ihre Hilfe!
Jeder kann seinen Beitrag leisten, unabhängig davon ob Sie neu im Projekt sind oder schon lange dabei sind, und ob Sie sich als
Entwickler, Endbenutzer oder einfach jemanden, der es einfach nicht aushält, Tippfehler zu sehen sehen.
Weitere Möglichkeiten, sich in der Kubernetes-Community zu engagieren oder mehr über uns zu erfahren, finden Sie auf der [Kubernetes-Community-Seite](/community/).
Informationen zum Handbuch zur Dokumentation von Kubernetes finden Sie im [Gestaltungshandbuch](/docs/contribute/style/style-guide/).
{{% capture body %}}
## Arten von Mitwirkenden
- Ein _Member_ der Kubernetes Organisation, hat die [CLA unterzeichnet](/docs/contribute/start#sign-the-cla)
und etwas Zeit und Energie zum Projekt beigetragen.
Siehe [Community-Mitgliedschaft](https://github.com/kubernetes/community/blob/master/community-membership.md) für spezifische Kriterien bezüglich der Mitgliedschaft.
- Ein SIG Docs _Reviewer_ ist ein Mitglied der Kubernetes-Organisation, das Interesse an der Überprüfung von
Dokumentationsanfragen geäußert hat und von einem SIG Docs Approver zu der entsprechenden Github-Gruppe
und den `OWNERS`-Dateien im Github-Repository hinzugefügt wurde.
- Ein SIG Docs _approver_ ist ein Mitglied mit gutem Ansehen, das sich kontinuierlich für das Projekt engagiert hat.
Ein Approver kann Pull-Anfragen zusammenführen und Inhalte im Namen der Kubernetes-Organisation veröffentlichen.
Approver können SIG Docs auch in der größeren Kubernetes-Community vertreten. Einige der Aufgaben eines SIG Docs Approvers, wie z.B. die Koordination einer Freigabe, erfordern einen erheblichen Zeitaufwand.
## Möglichkeiten, einen Beitrag zu leisten
Diese Liste ist in Funktionen unterteilt, die jeder tun kann, die von Mitgliedern der Kubernetes-Organisation durchgeführt werden können, und Dinge, die ein höheres Maß an Zugriff und eine bessere Kenntnis der SIG Docs-Prozesse erfordern. Wenn Sie im Laufe der Zeit einen konstanten Beitrag leisten, können Sie einige der bereits getroffenen Tools und organisatorischen Entscheidungen nachvollziehen.
Dies ist keine vollständige Liste von Möglichkeiten, wie Sie zur Kubernetes-Dokumentation beitragen können, aber sie sollte Ihnen den Einstieg erleichtern.
- [Jeder](/docs/contribute/start/)
- Umsetzbare issues eröffnen
- [Member](/docs/contribute/start/)
- Vorhandene Dokumente verbessern
- Ideen zur Verbesserung in [Slack](http://slack.k8s.io/) oder der [SIG docs Mailingliste](https://groups.google.com/forum/#!forum/kubernetes-sig-docs) einbringen
- Den Zugriff auf Dokumente verbessern
- Unverbindliches Feedback zu PRs verfassen
- Enen Blogbeitrag oder eine Fallstudie schreiben
- [Reviewer](/docs/contribute/intermediate/)
- Neue Funktionen dokumentieren
- Auswerten und Kategorisieren von Problemen
- PRs überprüfen
- Diagramme, Grafiken und einbettbare Screencasts / Videos erstellen
- Lokalisierung
- Als Vertreter von docs zu anderen Repos beitragen
- An Benutzer gerichtete Zeichenfolgen im Code bearbeiten
- Code-Kommentare verbessern, Godoc
- [Approver](/docs/contribute/advanced/)
- Veröffentlichen Sie den Inhalt von Members, indem Sie PRs genehmigen und zusammenführen
- Nehmen Sie als Docs-Vertreter an einem Kubernetes-Release-Team teil
- Verbesserungsvorschläge für den Style Guide
- Verbesserungsvorschläge für Dokumentprüfungen vorschlagen
- Vorschläge für Verbesserungen der Kubernetes-Website oder anderer Tools
{{% /capture %}}

56
content/de/docs/home/_index.md Normal file
View File

@ -0,0 +1,56 @@
---
title: Kubernetes Dokumentation
noedit: true
cid: docsHome
layout: docsportal_home
class: gridPage
linkTitle: "Home"
main_menu: true
weight: 10
hide_feedback: true
menu:
main:
title: "Dokumentation"
weight: 20
post: >
<p>Erfahren Sie, wie Sie Kubernetes mit Konzept-, Tutorial- und Referenzdokumentation verwenden. Sie können sogar zur <a href="/editdocs/" data-auto-burger-exclude>mithelfen und zur Dokumentation beitragen</a>!</p>
overview: >
Kubernetes ist ein Open-Source-System zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Das Open-Source Project wird von der Cloud Native Computing Foundation (<a href="https://www.cncf.io/about">CNCF</a>) gehosted.
cards:
- name: concepts
title: "Verstehen Sie die Grundlagen"
description: "Lernen Sie Kubernetes und seine grundlegenden Konzepte kennen."
button: "Konzepte lernen"
button_path: "/docs/concepts"
- name: tutorials
title: "Kubernetes ausprobieren"
description: "Folgen Sie den Tutorials, um zu erfahren, wie Sie Anwendungen in Kubernetes bereitstellen."
button: "Tutorials entdecken"
button_path: "/docs/tutorials"
- name: setup
title: "Richten Sie einen Cluster ein"
description: "Holen Sie sich Kubernetes basierend auf Ihren Ressourcen und Bedürfnissen."
button: "Kubernetes Einrichten"
button_path: "/docs/setup"
- name: tasks
title: "Erfahren Sie, wie Sie Kubernetes verwenden"
description: "Informieren Sie sich über häufig verwendete Aufgaben und deren Durchführung anhand einer kurzen Abfolge von Schritten."
button: "Tasks anzeigen"
button_path: "/docs/tasks"
- name: reference
title: Referenzinformationen nachschlagen
description: Durchsuchen Sie Terminologie, Befehlszeilensyntax, API-Ressourcentypen und Dokumentation zum Setup-Tool.
button: Referenz anzeigen
button_path: /docs/reference
- name: contribute
title: Tragen Sie zur Dokumentation bei
description: Jeder kann einen Beitrag leisten, unabhängig davon, ob Sie neu in dem Projekt oder schon lange dabei sind.
button: Zur Dokumentation beitragen
button_path: /docs/contribute
- name: download
title: Kubernetes Herunterladen
description: Wenn Sie Kubernetes installieren oder auf die neueste Version aktualisieren, lesen Sie die aktuellen Versionshinweise.
- name: about
title: Über die Dokumentation
description: Diese Website enthält Dokumentation zu den aktuellen und vorherigen 4 Versionen von Kubernetes.
---

30
content/de/docs/home/supported-doc-versions.md Normal file
View File

@ -0,0 +1,30 @@
---
title: Unterstützte Versionen der Kubernetes-Dokumentation
content_template: templates/concept
card:
name: about
weight: 10
title: Unterstützte Versionen der Dokumentation
---
{{% capture overview %}}
Diese Website enthält Dokumentation für die aktuelle Version von Kubernetes
und die vier vorherigen Versionen von Kubernetes.
{{% /capture %}}
{{% capture body %}}
## Aktuelle Version
Die aktuelle Version ist
[{{< param "version" >}}](/).
## Vorherige Versionen
{{< versions-other >}}
{{% /capture %}}

61
content/de/docs/reference/_index.md Normal file
View File

@ -0,0 +1,61 @@
---
title: Referenzen
approvers:
- chenopis
linkTitle: "Referenzen"
main_menu: true
weight: 70
content_template: templates/concept
---
{{% capture overview %}}
Dieser Abschnitt der Kubernetes-Dokumentation enthält Referenzinformationen.
{{% /capture %}}
{{% capture body %}}
## API-Referenz
* [Kubernetes API Überblick](/docs/reference/using-api/api-overview/) - Übersicht über die API für Kubernetes.
* Kubernetes API Versionen
* [1.14](/docs/reference/generated/kubernetes-api/v1.14/)
* [1.13](/docs/reference/generated/kubernetes-api/v1.13/)
* [1.12](/docs/reference/generated/kubernetes-api/v1.12/)
* [1.11](/docs/reference/generated/kubernetes-api/v1.11/)
* [1.10](/docs/reference/generated/kubernetes-api/v1.10/)
## API-Clientbibliotheken
Um die Kubernetes-API aus einer Programmiersprache aufzurufen, können Sie
[Clientbibliotheken](/docs/reference/using-api/client-libraries/) verwenden.
Offiziell unterstützte Clientbibliotheken:
- [Kubernetes Go Clientbibliothek](https://github.com/kubernetes/client-go/)
- [Kubernetes Python Clientbibliothek](https://github.com/kubernetes-client/python)
- [Kubernetes Java Clientbibliothek](https://github.com/kubernetes-client/java)
- [Kubernetes JavaScript Clientbibliothek](https://github.com/kubernetes-client/javascript)
## CLI-Referenz
* [kubectl](/docs/user-guide/kubectl-overview) - Haupt-CLI-Tool zum Ausführen von Befehlen und zum Verwalten von Kubernetes-Clustern.
* [JSONPath](/docs/user-guide/jsonpath/) - Syntax-Anleitung zur Verwendung von [JSONPath expressionen](http://goessner.net/articles/JsonPath/) mit kubectl.
* [kubeadm](/docs/admin/kubeadm/) - CLI-Tool zur einfachen Bereitstellung eines sicheren Kubernetes-Clusters.
* [kubefed](/docs/admin/kubefed/) - CLI-Tool zur Verwaltung Ihres Clusterverbunds.
## Konfigurationsreferenz
* [kubelet](/docs/admin/kubelet/) - Der primäre *Node-Agent*, der auf jedem Node ausgeführt wird. Das Kubelet betrachtet eine Reihe von PodSpecs und stellt sicher, dass die beschriebenen Container ordnungsgemäß ausgeführt werden.
* [kube-apiserver](/docs/admin/kube-apiserver/) - REST-API zur Überprüfung und Konfiguration von Daten für API-Objekte wie Pods, Services und Replikationscontroller.
* [kube-controller-manager](/docs/admin/kube-controller-manager/) - Daemon, der die mit Kubernetes gelieferten zentralen Regelkreise einbettet.
* [kube-proxy](/docs/admin/kube-proxy/) - Kann einfache TCP/UDP-Stream-Weiterleitung oder Round-Robin-TCP/UDP-Weiterleitung über eine Reihe von Back-Ends durchführen.
* [kube-scheduler](/docs/admin/kube-scheduler/) - Scheduler, der Verfügbarkeit, Leistung und Kapazität verwaltet.
* [federation-apiserver](/docs/admin/federation-apiserver/) - API-Server für Cluster Föderationen.
* [federation-controller-manager](/docs/admin/federation-controller-manager/) - Daemon, der die zentralen Regelkreise einbindet, die mit der Kubernetes-Föderation ausgeliefert werden.
## Design Dokumentation
Ein Archiv der Designdokumente für Kubernetes-Funktionalität. Gute Ansatzpunkte sind [Kubernetes Architektur](https://git.k8s.io/community/contributors/design-proposals/architecture/architecture.md) und [Kubernetes Design Übersicht](https://git.k8s.io/community/contributors/design-proposals).
{{% /capture %}}

5
content/de/docs/reference/access-authn-authz/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: API Zugriff
weight: 20
toc-hide: true
---

5
content/de/docs/reference/command-line-tools-reference/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: Befehlszeilen-Werkzeug Referenzinformationen
weight: 60
toc-hide: true
---

4
content/de/docs/reference/federation/_index.html Normal file
View File

@ -0,0 +1,4 @@
---
title: "Föderation API"
weight: 40
---

19
content/de/docs/reference/glossary/etcd.md Executable file
View File

@ -0,0 +1,19 @@
---
title: etcd
id: etcd
date: 2018-04-12
full_link: /docs/tasks/administer-cluster/configure-upgrade-etcd/
short_description: >
Konsistenter und hochverfügbarer Key-Value Speicher, der als Backupspeicher von Kubernetes für alle Clusterdaten verwendet wird.
aka:
tags:
- architecture
- storage
---
Konsistenter und hochverfügbarer Key-Value Speicher, der als Backupspeicher von Kubernetes für alle Clusterdaten verwendet wird.
<!--more-->
Halten Sie immer einen Sicherungsplan für etcds Daten für Ihren Kubernetes-Cluster bereit. Ausführliche Informationen zu etcd finden Sie in der [etcd Dokumentation](https://github.com/coreos/etcd/blob/master/Documentation/docs.md).

12
content/de/docs/reference/glossary/index.md Executable file
View File

@ -0,0 +1,12 @@
---
title: Standardisiertes Glossar
layout: glossary
noedit: true
default_active_tag: fundamental
weight: 5
card:
name: reference
weight: 10
title: Glossary
---

19
content/de/docs/reference/glossary/kube-apiserver.md Executable file
View File

@ -0,0 +1,19 @@
---
title: kube-apiserver
id: kube-apiserver
date: 2018-04-12
full_link: /docs/reference/generated/kube-apiserver/
short_description: >
Komponente auf dem Master, der die Kubernetes-API verfügbar macht. Es ist das Frontend für die Kubernetes-Steuerebene.
aka:
tags:
- architecture
- fundamental
---
Komponente auf dem Master, der die Kubernetes-API verfügbar macht. Es ist das Frontend für die Kubernetes-Steuerebene.
<!--more-->
Es ist für die horizontale Skalierung konzipiert, d. H. Es skaliert durch die Bereitstellung von mehr Instanzen. Mehr informationen finden Sie unter [Cluster mit hoher Verfügbarkeit erstellen](/docs/admin/high-availability/).

19
content/de/docs/reference/glossary/kube-controller-manager.md Executable file
View File

@ -0,0 +1,19 @@
---
title: kube-controller-manager
id: kube-controller-manager
date: 2018-04-12
full_link: /docs/reference/generated/kube-controller-manager/
short_description: >
Komponente auf dem Master, auf dem Controller ausgeführt werden.
aka:
tags:
- architecture
- fundamental
---
Komponente auf dem Master, auf dem {{< glossary_tooltip text="controllers" term_id="controller" >}} ausgeführt werden.
<!--more-->
Logisch gesehen ist jeder {{< glossary_tooltip text="controller" term_id="controller" >}} ein separater Prozess, aber zur Vereinfachung der Komplexität werden sie alle zu einer einzigen Binärdatei zusammengefasst und in einem einzigen Prozess ausgeführt.

19
content/de/docs/reference/glossary/kube-scheduler.md Executable file
View File

@ -0,0 +1,19 @@
---
title: kube-scheduler
id: kube-scheduler
date: 2018-04-12
full_link: /docs/reference/generated/kube-scheduler/
short_description: >
Komponente auf dem Master, die neu erstellte Pods überwacht, denen kein Node zugewiesen ist. Sie wählt den Node aus, auf dem sie ausgeführt werden sollen.
aka:
tags:
- architecture
---
Komponente auf dem Master, die neu erstellte Pods überwacht, denen kein Node zugewiesen ist. Sie wählt den Node aus, auf dem sie ausgeführt werden sollen.
<!--more-->
Zu den Faktoren, die bei Planungsentscheidungen berücksichtigt werden, zählen individuelle und kollektive Ressourcenanforderungen, Hardware- / Software- / Richtlinieneinschränkungen, Affinitäts- und Anti-Affinitätsspezifikationen, Datenlokalität, Interworkload-Interferenz und Deadlines.

18
content/de/docs/reference/glossary/kubelet.md Executable file
View File

@ -0,0 +1,18 @@
---
title: Kubelet
id: kubelet
date: 2018-04-12
full_link: /docs/reference/generated/kubelet
short_description: >
Ein Agent, der auf jedem Node im Cluster ausgeführt wird. Er stellt sicher, dass Container in einem Pod ausgeführt werden.
aka:
tags:
- fundamental
- core-object
---
Ein Agent, der auf jedem Node im Cluster ausgeführt wird. Er stellt sicher, dass Container in einem Pod ausgeführt werden.
<!--more-->
Das Kubelet verwendet eine Reihe von PodSpecs, die über verschiedene Mechanismen bereitgestellt werden, und stellt sicher, dass die in diesen PodSpecs beschriebenen Container ordnungsgemäß ausgeführt werden. Das kubelet verwaltet keine Container, die nicht von Kubernetes erstellt wurden.

5
content/de/docs/reference/issues-security/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: Kubernetes Probleme und Sicherheit
weight: 10
toc-hide: true
---

5
content/de/docs/reference/kubectl/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "kubectl CLI"
weight: 60
---

351
content/de/docs/reference/kubectl/cheatsheet.md Normal file
View File

@ -0,0 +1,351 @@
---
title: kubectl Spickzettel
content_template: templates/concept
card:
name: reference
weight: 30
---
{{% capture overview %}}
Siehe auch: [Kubectl Überblick](/docs/reference/kubectl/overview/) und [JsonPath Dokumentation](/docs/reference/kubectl/jsonpath).
Diese Seite ist eine Übersicht über den Befehl `kubectl`.
{{% /capture %}}
{{% capture body %}}
# kubectl - Spickzettel
## Kubectl Autovervollständigung
### BASH
```bash
source <(kubectl completion bash) # Wenn Sie autocomplete in bash in der aktuellen Shell einrichten, sollte zuerst das bash-completion-Paket installiert werden.
echo "source <(kubectl completion bash)" >> ~/.bashrc # Fügen Sie der Bash-Shell dauerhaft Autocomplete hinzu.
```
Sie können auch ein Abkürzungsalias für `kubectl` verwenden, weleches auch mit Vervollständigung funktioniert:
```bash
alias k=kubectl
complete -F __start_kubectl k
```
### ZSH
```bash
source <(kubectl completion zsh) # Richten Sie Autocomplete in zsh in der aktuellen Shell ein
echo "if [ $commands[kubectl] ]; then source <(kubectl completion zsh); fi" >> ~/.zshrc # Fügen Sie der Zsh-Shell dauerhaft Autocomplete hinzu
```
## Kubectl Kontext und Konfiguration
Legen Sie fest, welcher Kubernetes-Cluster mit `kubectl` kommuniziert und dessen Konfiguration ändert. Lesen Sie die Dokumentation [Authentifizierung mit kubeconfig über mehrere Cluster hinweg](/docs/tasks/access-application-cluster/configure-access-multiple-clusters/) für ausführliche Informationen zur Konfigurationsdatei.
```bash
kubectl config view # Zusammengeführte kubeconfig-Einstellungen anzeigen.
# Verwenden Sie mehrere kubeconfig-Dateien gleichzeitig und zeigen Sie die zusammengeführte Konfiguration an
KUBECONFIG=~/.kube/config:~/.kube/kubconfig2 kubectl config view
# Zeigen Sie das Passwort für den e2e-Benutzer an
kubectl config view -o jsonpath='{.users[?(@.name == "e2e")].user.password}'
kubectl config view -o jsonpath='{.users[].name}' # eine Liste der Benutzer erhalten
kubectl config current-context # den aktuellen Kontext anzeigen
kubectl config use-context my-cluster-name # Setzen Sie den Standardkontext auf my-cluster-name
# Fügen Sie Ihrer kubeconf einen neuen Cluster hinzu, der basic auth unterstützt
kubectl config set-credentials kubeuser/foo.kubernetes.com --username=kubeuser --password=kubepassword
# Legen Sie einen Kontext fest, indem Sie einen bestimmten Benutzernamen und einen bestimmten Namespace verwenden.
kubectl config set-context gce --user=cluster-admin --namespace=foo \
&& kubectl config use-context gce
kubectl config unset users.foo # delete user foo
```
## Apply
`apply` verwaltet Anwendungen durch Dateien, die Kubernetes-Ressourcen definieren. Es erstellt und aktualisiert Ressourcen in einem Cluster durch Ausführen von `kubectl apply`. Dies ist die empfohlene Methode zur Verwaltung von Kubernetes-Anwendungen in der Produktion. Lesen Sie die ausführliche [Kubectl Dokumentation](https://kubectl.docs.kubernetes.io) für weitere Informationen.
## Objekte erstellen
Kubernetes Manifeste können in Json oder Yaml definiert werden. Die Dateierweiterungen `.yaml`,
`.yml`, und `.json` können verwendet werden.
```bash
kubectl apply -f ./my-manifest.yaml # Ressource(n) erstellen
kubectl apply -f ./my1.yaml -f ./my2.yaml # aus mehreren Dateien erstellen
kubectl apply -f ./dir # Erstellen Sie Ressourcen in allen Manifestdateien in Verzeichnis
kubectl apply -f https://git.io/vPieo # Ressource(n) aus URL erstellen
kubectl create deployment nginx --image=nginx # Starten Sie eine einzelne Instanz von Nginx
kubectl explain pods,svc # Zeigen Sie die Dokumentation für Pod und SVC Manifeste an
# Erstellen Sie mehrere YAML-Objekte aus stdin
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000000"
---
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep-less
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000"
EOF
# Erstellen Sie ein "Secret" mit mehreren Schlüsseln
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Secret
metadata:
name: mysecret
type: Opaque
data:
password: $(echo -n "s33msi4" | base64 -w0)
username: $(echo -n "jane" | base64 -w0)
EOF
```
## Suchen und Anzeigen von Ressourcen
```bash
# Get Befehle mit grundlegenden Ausgaben
kubectl get services # Listen Sie alle Dienste im Namespace auf
kubectl get pods --all-namespaces # Listen Sie alle Pods in allen Namespaces auf
kubectl get pods -o wide # Listen Sie alle Pods im Namespace mit weiteren Details auf
kubectl get deployment my-dep # Listen Sie eine bestimmte Bereitstellung auf
kubectl get pods --include-uninitialized # Listen Sie alle Pods im Namespace auf, einschließlich der nicht initialisierten
# Describe Befehle mit ausführlicher Ausgabe
kubectl describe nodes my-node
kubectl describe pods my-pod
kubectl get services --sort-by=.metadata.name # Listen Sie Dienste nach Namen sortiert auf
# Listen Sie Pods Sortiert nach Restart Count auf
kubectl get pods --sort-by='.status.containerStatuses[0].restartCount'
# Erhalten Sie die Versionsbezeichnung aller Pods mit der Bezeichnung app=cassandra
kubectl get pods --selector=app=cassandra rc -o \
jsonpath='{.items[*].metadata.labels.version}'
# Alle Worker-Knoten abrufen (verwenden Sie einen Selektor, um Ergebnisse auszuschließen,
# die ein Label mit dem Namen 'node-role.kubernetes.io/master' tragen).
kubectl get node --selector='!node-role.kubernetes.io/master'
# Zeigen Sie alle laufenden Pods im Namespace an
kubectl get pods --field-selector=status.phase=Running
# Rufen Sie die externe IP aller Nodes ab
kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'
# Listet die Namen der Pods auf, die zu einem bestimmten RC gehören
# Der Befehl "jq" ist nützlich für Transformationen, die für jsonpath zu komplex sind. Sie finden ihn unter https://stedolan.github.io/jq/
sel=${$(kubectl get rc my-rc --output=json | jq -j '.spec.selector | to_entries | .[] | "\(.key)=\(.value),"')%?}
echo $(kubectl get pods --selector=$sel --output=jsonpath={.items..metadata.name})
# Labels für alle Pods anzeigen (oder jedes andere Kubernetes-Objekt, das labelling unterstützt)
# Verwendet auch "jq"
for item in $( kubectl get pod --output=name); do printf "Labels for %s\n" "$item" | grep --color -E '[^/]+$' && kubectl get "$item" --output=json | jq -r -S '.metadata.labels | to_entries | .[] | " \(.key)=\(.value)"' 2>/dev/null; printf "\n"; done
# Prüfen Sie, welche Nodes bereit sind
JSONPATH='{range .items[*]}{@.metadata.name}:{range @.status.conditions[*]}{@.type}={@.status};{end}{end}' \
&& kubectl get nodes -o jsonpath="$JSONPATH" | grep "Ready=True"
# Listen Sie alle Secrets auf, die derzeit von einem Pod verwendet werden
kubectl get pods -o json | jq '.items[].spec.containers[].env[]?.valueFrom.secretKeyRef.name' | grep -v null | sort | uniq
# Ereignisse nach Zeitstempel sortiert auflisten
kubectl get events --sort-by=.metadata.creationTimestamp
```
## Ressourcen aktualisieren
Ab Version 1.11 ist das `rolling-update` veraltet (Lesen Sie [CHANGELOG-1.11.md](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.11.md) für weitere Informationen), verwenden Sie stattdessen `rollout`.
```bash
kubectl set image deployment/frontend www=image:v2 # Fortlaufende Aktualisierung der "www" Container der "Frontend"-Bereitstellung, Aktualisierung des Images
kubectl rollout undo deployment/frontend # Rollback zur vorherigen Bereitstellung
kubectl rollout status -w deployment/frontend # Beobachten Sie den fortlaufenden Aktualisierungsstatus der "Frontend"-Bereitstellung bis zum Abschluss.
# veraltet ab Version 1.11
kubectl rolling-update frontend-v1 -f frontend-v2.json # (veraltet) Fortlaufendes Update der Pods von Frontend-v1
kubectl rolling-update frontend-v1 frontend-v2 --image=image:v2 # (veraltet) Ändern Sie den Namen der Ressource und aktualisieren Sie das Image
kubectl rolling-update frontend --image=image:v2 # (veraltet) Aktualisieren Sie das Pod-Image des Frontends
kubectl rolling-update frontend-v1 frontend-v2 --rollback # (veraltet) Bricht das laufende Rollout ab
cat pod.json | kubectl replace -f - # Ersetzen Sie einen Pod basierend auf der in std übergebenen JSON
# Ersetzen, löschen und Ressource neu erstellen. Dies führt zu einer temprären Unerreichbarkeit des Dienstes.
kubectl replace --force -f ./pod.json
# Erstellen Sie einen Dienst für eien replizierten nginx Webserver, der an Port 80 und in den Containern an Port 8000 lauscht
kubectl expose rc nginx --port=80 --target-port=8000
# Aktualisieren Sie die Image-Version (Tag) eines Einzelcontainer-Pods auf Version 4
kubectl get pod mypod -o yaml | sed 's/\(image: myimage\):.*$/\1:v4/' | kubectl replace -f -
kubectl label pods my-pod new-label=awesome # Label hinzufügen
kubectl annotate pods my-pod icon-url=http://goo.gl/XXBTWq # Eine Anmerkung hinzufügen
kubectl autoscale deployment foo --min=2 --max=10 # Automatische Skalierung einer Bereitstellung "Foo"
```
## Ressourcen patchen
```bash
kubectl patch node k8s-node-1 -p '{"spec":{"unschedulable":true}}' # Aktualisieren Sie einen Node teilweise
# Aktualisieren Sie das Image eines Containers; spec.containers[*].name ist erforderlich, da es sich um einen Merge-Schlüssel handelt
kubectl patch pod valid-pod -p '{"spec":{"containers":[{"name":"kubernetes-serve-hostname","image":"new image"}]}}'
# Aktualisieren Sie das Image eines Containers mithilfe eines Json-Patches mit Positionsarrays
kubectl patch pod valid-pod --type='json' -p='[{"op": "replace", "path": "/spec/containers/0/image", "value":"new image"}]'
# Deaktivieren Sie eine Bereitstellung von livenessProbe durch verwenden eines Json-Patches mit Positionsarrays
kubectl patch deployment valid-deployment --type json -p='[{"op": "remove", "path": "/spec/template/spec/containers/0/livenessProbe"}]'
# Fügen Sie einem Positionsarray ein neues Element hinzu
kubectl patch sa default --type='json' -p='[{"op": "add", "path": "/secrets/1", "value": {"name": "whatever" } }]'
```
## Ressourcen bearbeiten
Bearbeiten Sie eine beliebige API-Ressource in einem Editor.
```bash
kubectl edit svc/docker-registry # Bearbeiten Sie den Dienst docker-registry
KUBE_EDITOR="nano" kubectl edit svc/docker-registry # Verwenden Sie einen alternativen Texteditor
```
## Ressourcen skalieren
```bash
kubectl scale --replicas=3 rs/foo # Skaliert ein Replikat mit dem Namen 'foo' auf 3
kubectl scale --replicas=3 -f foo.yaml # Skaliert eine in "foo.yaml" angegebene Ressource auf 3
kubectl scale --current-replicas=2 --replicas=3 deployment/mysql # Wenn die aktuelle Konfiguration der Replikation von mysql 2 ist, skaliert mysql auf 3
kubectl scale --replicas=5 rc/foo rc/bar rc/baz # Skaliert mehrere Replikationscontroller
```
## Ressourcen löschen
```bash
kubectl delete -f ./pod.json # Löscht einen Pod mit dem in pod.json angegebenen Typ und Namen
kubectl delete pod,service baz foo # Löscht Pods und Services mit den gleichen Namen "baz" und "foo"
kubectl delete pods,services -l name=myLabel # Löscht Pods und Services mit dem Label name=myLabel
kubectl delete pods,services -l name=myLabel --include-uninitialized # Löscht Pods und Services, einschließlich nicht initialisierter, mit dem Label name=myLabel
kubectl -n my-ns delete po,svc --all # Löscht alle Pods und Dienste, einschließlich nicht initialisierter, im Namespace my-ns,
```
## Interaktion mit laufenden Pods
```bash
kubectl logs my-pod # Pod-Logdatei ausgeben (stdout)
kubectl logs my-pod --previous # Pod-Logdatei für eine vorherige Instantiierung eines Containers ausgeben (stdout)
kubectl logs my-pod -c my-container # Pod Container-Logdatei ausgeben (stdout, multi-container case)
kubectl logs my-pod -c my-container --previous # Pod Container-Logdatei für eine vorherige Instantiierung eines Containers ausgeben (stdout, multi-container case)
kubectl logs -f my-pod # Pod-Logdatei streamen (stdout)
kubectl logs -f my-pod -c my-container # Pod Container-Logdatei streamen (stdout, multi-container case)
kubectl run -i --tty busybox --image=busybox -- sh # Pod als interaktive Shell ausführen
kubectl attach my-pod -i # An laufenden Container anhängen
kubectl port-forward my-pod 5000:6000 # Lauscht auf Port 5000 auf dem lokalen Computer und leitet den Port 6000 auf my-pod weiter
kubectl exec my-pod -- ls / # Befehl in vorhandenem Pod ausführen (1 Container)
kubectl exec my-pod -c my-container -- ls / # Befehl in vorhandenem Pod ausführen (Mehrere Container)
kubectl top pod POD_NAME --containers # Zeigt Metriken für einen bestimmten Pod und seine Container an
```
## Mit Nodes und Clustern interagieren
```bash
kubectl cordon my-node # Markiert "my-node" als unplanbar
kubectl drain my-node # Entleert "my-node" zur Vorbereitung der Wartung
kubectl uncordon my-node # Markiert "my-node" als planbar
kubectl top node my-node # Metriken für einen bestimmten Node anzeigen
kubectl cluster-info # Adressen des Masters und der Services anzeigen
kubectl cluster-info dump # Ausgabe des aktuellen Clusterstatus in stdout
kubectl cluster-info dump --output-directory=/pfad/zum/cluster-status # Aktuellen Cluster-Status in /pfad/zum/cluster-status ausgeben
# Wenn bereits ein Taint mit diesem Key und Effekt vorhanden ist, wird sein Wert wie angegeben ersetzt.
kubectl taint nodes foo dedicated=special-user:NoSchedule
```
### Ressourcentypen
Liste aller unterstützten Ressourcentypen mit ihren Kurzbezeichnungen, der [API-Gruppe](/docs/concepts/overview/kubernetes-api/#api-groups), unabhängig davon ob sie im Namespace liegen, und der [Art](/docs/concepts/overview/working-with-objects/kubernetes-objects):
```bash
kubectl api-resources
```
Andere Operationen zum Erkunden von API-Ressourcen:
```bash
kubectl api-resources --namespaced=true # Alle Ressourcen im Namespace
kubectl api-resources --namespaced=false # Alle nicht im Namespace befindlichen Ressourcen
kubectl api-resources -o name # Alle Ressourcen mit einfacher Ausgabe (nur der Ressourcenname)
kubectl api-resources -o wide # Alle Ressourcen mit erweiterter Ausgabe (aka "Wide")
kubectl api-resources --verbs=list,get # Alle Ressourcen, die "list" und "get" Verben unterstützen anfordern
kubectl api-resources --api-group=extensions # Alle Ressourcen in der API-Gruppe "extensions"
```
### Ausgabe formatieren
Um Details in einem bestimmten Format an Ihr Terminalfenster auszugeben, können Sie entweder das `-o` oder `--output` Flag zu einem unterstützten `kubectl` Befehl anhängens.
Ausgabeformat | Beschreibung
--------------| -----------
`-o=custom-columns=<spec>` | Ausgabe einer Tabelle mit einer durch Kommas getrennten Liste benutzerdefinierter Spalten
`-o=custom-columns-file=<dateiname>` | Drucken Sie eine Tabelle mit der benutzerdefinierten Spaltenvorlage in der `<dateiname>` Datei
`-o=json` | Ausgabe eines JSON-formatierten API-Objekts
`-o=jsonpath=<template>` | Ausgabe der in einem [jsonpath](/docs/reference/kubectl/jsonpath)-Ausdruck definierten Felder
`-o=jsonpath-file=<dateiname>` | Ausgabe der in einem [jsonpath](/docs/reference/kubectl/jsonpath)-Ausdruck definierten Felder in der `<dateiname>` Datei
`-o=name` | Ausgabe von nur dem Ressourcennamen und nichts anderes
`-o=wide` | Ausgabe im Klartextformat mit zusätzlichen Informationen. Bei Pods ist der Node-Name enthalten
`-o=yaml` | Gibt ein YAML-formatiertes API-Objekt aus
### Kubectl Ausgabe Ausführlichkeit und Debugging
Die Ausführlichkeit von Kubectl wird mit den Flags `-v` oder `--v ` gesteuert, gefolgt von einer Ganzzahl, die die Protokollebene darstellt. Allgemeine Protokollierungskonventionen für Kubernetes und die zugehörigen Protokollebenen werden [hier](https://github.com/kubernetes/community/blob/master/contributors/devel/logging.md) beschrieben.
Ausführlichkeit | Beschreibung
--------------| -----------
`--v=0` | Allgemein nützlich, damit dies für den Bediener IMMER sichtbar ist.
`--v=1` | Eine vernünftige Standardprotokollebene, wenn Sie keine Ausführlichkeit wünschen.
`--v=2` | Nützliche Informationen zum stabilen Status des Dienstes und wichtige Protokollnachrichten, die möglicherweise zu erheblichen Änderungen im System führen. Dies ist die empfohlene Standardprotokollebene für die meisten Systeme.
`--v=3` | Erweiterte Informationen zu Änderungen.
`--v=4` | Debug-Level-Ausführlichkeit.
`--v=6` | Angeforderte Ressourcen anzeigen
`--v=7` | HTTP-Anforderungsheader anzeigen
`--v=8` | HTTP-Anforderungsinhalt anzeigen
`--v=9` | HTTP-Anforderungsinhalt anzeigen, ohne den Inhalt zu kürzen.
{{% /capture %}}
{{% capture whatsnext %}}
* Lernen Sie mehr im [Überblick auf kubectl](/docs/reference/kubectl/overview/).
* Erkunden Sie [kubectl](/docs/reference/kubectl/kubectl/) Optionen.
* Und ebenfalls die [kubectl Nutzungskonventionen](/docs/reference/kubectl/conventions/) um zu verstehen, wie man es in wiederverwendbaren Skripten verwendet.
* Entdecken Sie mehr Community [kubectl Spickzettel](https://github.com/dennyzhang/cheatsheet-kubernetes-A4).
{{% /capture %}}

4
content/de/docs/reference/kubernetes-api/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: API Referenzinformationen
weight: 30
---

5
content/de/docs/reference/setup-tools/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: Setup-Tools Referenzinformationen
weight: 50
toc-hide: true
---

52
content/de/docs/reference/tools.md Normal file
View File

@ -0,0 +1,52 @@
---
title: Tools
content_template: templates/concept
---
{{% capture overview %}}
Kubernetes enthält mehrere integrierte Tools, die Ihnen bei der Arbeit mit dem Kubernetes System helfen.
{{% /capture %}}
{{% capture body %}}
## Kubectl
[`kubectl`](/docs/tasks/tools/install-kubectl/) ist ein Kommandozeilenprogramm für Kubernetes. Es steuert den Kubernetes Clustermanager.
## Kubeadm
[`kubeadm`](/docs/setup/independent/install-kubeadm/) ist ein Kommandozeilenprogramm zur einfachen Bereitstellung eines sicheren Kubernetes-Clusters auf physischen oder Cloud-Servern oder virtuellen Maschinen (derzeit in alpha).
## Kubefed
[`kubefed`](/docs/tasks/federation/set-up-cluster-federation-kubefed/) ist ein Kommandozeilenprogramm um Ihnen bei der Verwaltung Ihrer Verbundcluster zu helfen.
## Minikube
[`minikube`](/docs/tasks/tools/install-minikube/) ist ein Tool, das es Ihnen einfach macht, einen Kubernetes-Cluster mit einem einzigen Knoten lokal auf Ihrer Workstation für Entwicklungs- und Testzwecke auszuführen.
## Dashboard
[`Dashboard`](/docs/tasks/access-application-cluster/web-ui-dashboard/), die webbasierte Benutzeroberfläche von Kubernetes ermöglicht es Ihnen containerisierte Anwendungen in einem Kubernetes-Cluster bereitzustellen Fehler zu beheben und den Cluster und seine Ressourcen selbst zu verwalten.
## Helm
[`Kubernetes Helm`](https://github.com/kubernetes/helm) ist ein Tool zur Verwaltung von Paketen mit vorkonfigurierten Kubernetes-Ressourcen, auch bekannt als Kubernetes charts.
Verwenden Sie Helm um:
* Beliebte Software verpackt als Kubernetes charts zu finden und zu verwenden
* Ihre eigenen Applikationen als Kubernetes charts zu teilen
* Reproduzierbare Builds Ihrer Kubernetes Anwendungen zu erstellen
* Intelligenten Verwaltung von Ihren Kubernetes manifest files
* Verwalten von Versionen von Helm Paketen
## Kompose
[`Kompose`](https://github.com/kubernetes-incubator/kompose) ist ein Tool, das Docker Compose Benutzern hilft, nach Kubernetes zu wechseln.
Verwenden Sie Kompose um:
* Ein Docker Compose Datei in Kubernetes Objekte zu übersetzen
* Von Ihrer lokalen Docker Entwicklung auf eine Kubernetes verwaltete Entwicklung zu wechseln
* v1 oder v2 Docker Compose `yaml` Dateien oder [Distributed Application Bundles](https://docs.docker.com/compose/bundles/) zu konvertieren
{{% /capture %}}

5
content/de/docs/reference/using-api/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: Verwendung der Kubernetes-API
weight: 10
toc-hide: true
---

5
content/de/docs/search.md Normal file
View File

@ -0,0 +1,5 @@
---
layout: search
title: Suchergebnisse
---

82
content/de/docs/setup/_index.md Normal file
View File

@ -0,0 +1,82 @@
---
title: Setup
main_menu: true
weight: 30
content_template: templates/concept
---
{{% capture overview %}}
Auf dieser Seite finden Sie die Lösung, die Ihren Anforderungen am besten entspricht.
Die Entscheidung, wo Kubernetes ausgeführt wird, hängt davon ab, welche Ressourcen Sie zur Verfügung haben und wie viel Flexibilität Sie benötigen.
Sie können Kubernetes fast überall ausführen, von Ihrem Laptop über VMs bei einem Cloud-Anbieter bis hin zu Bare-Metal-Servern.
Sie können einen vollständig verwalteten Cluster einrichten, indem Sie einen einzelnen Befehl ausführen oder einen eigenen benutzerdefinierten Cluster auf Ihren Bare-Metal-Servern erstellen.
{{% /capture %}}
{{% capture body %}}
## Lösungen für lokale Maschinen
Eine lokale Lösung ist eine einfache Möglichkeit, mit Kubernetes anzufangen.
Sie können Kubernetes-Cluster erstellen und testen, ohne sich Gedanken über den Verbrauch von Cloud-Ressourcen und -Kontingenten machen zu müssen.
Sie sollten eine lokale Lösung auswählen, wenn Sie:
* Zum ausprobieren oder wenn Sie etwas über Kubernetes lernen möchten
* Cluster lokal entwickeln und testen
Wählen Sie eine [lokale Lösung](/de/docs/setup/) aus.
## Gehostete Lösungen
Gehostete Lösungen sind eine bequeme Möglichkeit, Kubernetes-Cluster zu erstellen und zu warten.
Sie verwalten und betreiben Ihre Cluster, so dass Sie dies nicht tun müssen.
Sie sollten eine gehostete Lösung auswählen, wenn Sie:
* Eine vollständig verwaltete Lösung wünschen
* Sie möchten sich auf die Entwicklung Ihrer Apps oder Dienste konzentrieren
* Sie haben kein dediziertes Site-Reliability-Engineering-Team (SRE), möchten jedoch eine hohe Verfügbarkeit
* Sie haben keine Ressourcen zum Hosten und Überwachen Ihrer Cluster
Wählen Sie eine [gehostete Lösung](/de/docs/setup/) aus.
## Schlüsselfertige Cloud-Lösungen
Mit diesen Lösungen können Sie Kubernetes-Cluster mit nur wenigen Befehlen erstellen. Sie werden aktiv entwickelt und verfügen über eine Community-Unterstützung.
Sie können auch auf einer Reihe von Cloud-IaaS-Anbietern gehostet werden, und bieten mehr Freiheit und Flexibilität für eine Gegenleistung.
Sie sollten eine schlüsselfertige Cloud-Lösung auswählen, wenn Sie:
* Mehr Kontrolle über Ihre Cluster haben möchten, als die gehosteten Lösungen zulassen
* Mehr operative Verantwortung übernehmen Möchten
Wählen Sie eine [schlüsselfertige Cloud-Lösung](/de/docs/setup/) aus.
## Schlüsselfertige On-Premises-Lösungen
Mit diesen Lösungen können Sie Kubernetes-Cluster mit nur wenigen Befehlen in Ihrem internen, sicheren Cloud-Netzwerk erstellen.
Sie sollten eine schlüsselfertige lokal betriebene Cloud-Lösung auswählen, wenn Sie:
* Cluster in Ihrem privaten Cloud-Netzwerk bereitstellen möchten
* Ein engagiertes SRE-Team haben
* Über die Ressourcen zum Hosten und Überwachen Ihrer Cluster verfügen
Wählen Sie eine [schlüsselfertige On-Premises-Lösung](/de/docs/setup/) aus.
## Individuelle Lösungen
Individuelle Lösungen geben Ihnen die größte Freiheit in Ihren Clustern, erfordern jedoch das meiste Know-how.
Diese Lösungen reichen von Bare-Metal-Anbietern bis hin zu Cloud-Anbietern mit unterschiedlichen Betriebssystemen.
Wählen Sie eine [individuelle Lösung](/de/docs/setup/) aus.
{{% /capture %}}
{{% capture whatsnext %}}
Gehen Sie zu [Auswählen der richtigen Lösung](/de/docs/setup/) für eine vollständige Liste der möglichen Lösungen.
{{% /capture %}}

4
content/de/docs/setup/custom-cloud/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: Indivduelle Cloud-Lösungen
weight: 50
---

5
content/de/docs/setup/independent/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Cluster mit kubeadm bootstrappen"
weight: 30
---

442
content/de/docs/setup/minikube.md Normal file
View File

@ -0,0 +1,442 @@
---
title: Kubernetes lokal über Minikube betreiben
content_template: templates/concept
---
{{% capture overview %}}
Minikube ist ein Tool, mit dem Kubernetes lokal einfach ausgeführt werden kann. Minikube führt einen Kubernetes-Cluster mit einem einzigen Node in einer VM auf Ihrem Laptop aus, damit Anwender Kubernetes ausprobieren oder täglich damit entwickeln können.
{{% /capture %}}
{{% capture body %}}
## Minikube-Funktionen
* Minikube unterstützt Kubernetes-Funktionen wie:
* DNS
* NodePorts
* ConfigMaps and Secrets
* Dashboards
* Container Laufzeiumgebungen: Docker, [rkt](https://github.com/rkt/rkt), [CRI-O](https://github.com/kubernetes-incubator/cri-o) und [containerd](https://github.com/containerd/containerd)
* Unterstützung von CNI (Container Network Interface)
* Ingress
## Installation
Lesen Sie [Minikube installieren](/docs/tasks/tools/install-minikube/) für Informationen zur Installation von Minikubes.
## Schnellstart
Folgend finden Sie eine kurze Demo zur Verwendung von Minikube.
Wenn Sie den VM-Treiber ändern möchten, fügen Sie das entsprechende `--vm-driver=xxx`-Flag zu `minikube start` hinzu.
Minikube unterstützt die folgenden Treiber:
* virtualbox
* vmwarefusion
* kvm2 ([Treiber installation](https://git.k8s.io/minikube/docs/drivers.md#kvm2-driver))
* kvm ([Treiber installation](https://git.k8s.io/minikube/docs/drivers.md#kvm-driver))
* hyperkit ([Treiber installation](https://git.k8s.io/minikube/docs/drivers.md#hyperkit-driver))
* xhyve ([Treiber installation](https://git.k8s.io/minikube/docs/drivers.md#xhyve-driver)) (deprecated)
* hyperv ([Treiber installation](https://github.com/kubernetes/minikube/blob/master/docs/drivers.md#hyperv-driver))
Beachten Sie, dass die unten angegebene IP-Adresse dynamisch ist und sich ändern kann. Sie kann mit `minikube ip` abgerufen werden.
* none (Führt die Kubernetes-Komponenten auf dem Host und nicht in einer VM aus. Die Verwendung dieses Treibers erfordert Docker ([Docker installieren](https://docs.docker.com/install/linux/docker-ce/ubuntu/)) und eine Linux-Umgebung)
```shell
minikube start
```
```
Starting local Kubernetes cluster...
Running pre-create checks...
Creating machine...
Starting local Kubernetes cluster...
```
```shell
kubectl run hello-minikube --image=k8s.gcr.io/echoserver:1.10 --port=8080
```
```
deployment.apps/hello-minikube created
```
```shell
kubectl expose deployment hello-minikube --type=NodePort
```
```
service/hello-minikube exposed
```
```
# Wir haben jetzt einen echoserver Pod gestartet, aber wir müssen warten,
# bis der Pod betriebsbereit ist, bevor wir über den exponierten Dienst auf ihn zugreifen können.
# Um zu überprüfen, ob der Pod läuft, können wir Folgendes verwenden:
kubectl get pod
```
```
NAME READY STATUS RESTARTS AGE
hello-minikube-3383150820-vctvh 0/1 ContainerCreating 0 3s
```
```
# Wir können anhand des ContainerCreating-Status sehen, dass der Pod immer noch erstellt wird.
kubectl get pod
```
```
NAME READY STATUS RESTARTS AGE
hello-minikube-3383150820-vctvh 1/1 Running 0 13s
```
```
# Wir können sehen, dass der Pod jetzt läuft und wir können ihn jetzt mit curl kontaktieren:
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"...
```
### Alternative Containerlaufzeitumgebungen
#### containerd
Um [containerd](https://github.com/containerd/containerd) als Containerlaufzeitumgebung zu verwenden, führen Sie den folgenden Befehl aus:
```bash
minikube start \
--network-plugin=cni \
--enable-default-cni \
--container-runtime=containerd \
--bootstrapper=kubeadm
```
Oder verwenden Sie die erweiterte Version:
```bash
minikube start \
--network-plugin=cni \
--enable-default-cni \
--extra-config=kubelet.container-runtime=remote \
--extra-config=kubelet.container-runtime-endpoint=unix:///run/containerd/containerd.sock \
--extra-config=kubelet.image-service-endpoint=unix:///run/containerd/containerd.sock \
--bootstrapper=kubeadm
```
#### CRI-O
Um [CRI-O](https://github.com/kubernetes-incubator/cri-o) als Containerlaufzeitumgebung zu verwenden, führen Sie den folgenden Befehl aus:
```bash
minikube start \
--network-plugin=cni \
--enable-default-cni \
--container-runtime=cri-o \
--bootstrapper=kubeadm
```
Oder verwenden Sie die erweiterte Version:
```bash
minikube start \
--network-plugin=cni \
--enable-default-cni \
--extra-config=kubelet.container-runtime=remote \
--extra-config=kubelet.container-runtime-endpoint=/var/run/crio.sock \
--extra-config=kubelet.image-service-endpoint=/var/run/crio.sock \
--bootstrapper=kubeadm
```
#### rkt container engine
Um [rkt](https://github.com/rkt/rkt) als Containerlaufzeitumgebung zu verwenden, führen Sie den folgenden Befehl aus:
```shell
minikube start \
--network-plugin=cni \
--enable-default-cni \
--container-runtime=rkt
```
Hierbei wird ein alternatives Minikube-ISO-Image verwendet, das sowohl rkt als auch Docker enthält, und CNI-Netzwerke ermöglichen.
### Treiber Plugins
Weitere Informationen zu unterstützten Treibern und zur Installation von Plugins finden Sie bei Bedarf unter [TREIBER](https://git.k8s.io/minikube/docs/drivers.md).
### Lokale Images durch erneute Verwendung des Docker-Daemon ausführen
Wenn Sie eine einzige Kubernetes VM verwenden, ist es sehr praktisch, den integrierten Docker-Daemon von Minikube wiederzuverwenden; Dies bedeutet, dass Sie auf Ihrem lokalen Computer keine Docker-Registy erstellen und das Image in die Registry importortieren müssen - Sie können einfach innerhalb desselben Docker-Daemons wie Minikube arbeiten, was lokale Experimente beschleunigt. Stellen Sie einfach sicher, dass Sie Ihr Docker-Image mit einem anderen Element als 'latest' versehen, und verwenden Sie dieses Tag, wenn Sie das Image laden. Andernfalls, wenn Sie keine Version Ihres Images angeben, wird es als `:latest` angenommen, mit der Pull-Image-Richtlinie von `Always` entsprechend, was schließlich zu `ErrImagePull` führen kann, da Sie möglicherweise noch keine Versionen Ihres Docker-Images in der Standard-Docker-Registry (normalerweise DockerHub) haben.
Um mit dem Docker-Daemon auf Ihrem Mac/Linux-Computer arbeiten zu können, verwenden Sie den `docker-env`-Befehl in Ihrer Shell:
```shell
eval $(minikube docker-env)
```
Sie sollten nun Docker in der Befehlszeile Ihres Mac/Linux-Computers verwenden können, um mit dem Docker-Daemon in der Minikube-VM zu sprechen:
```shell
docker ps
```
In Centos 7 meldets Docker möglicherweise den folgenden Fehler:
```shell
Could not read CA certificate "/etc/docker/ca.pem": open /etc/docker/ca.pem: no such file or directory
```
Das Update besteht darin, `/etc/sysconfig/docker` zu aktualisieren, um sicherzustellen, dass die Umgebungsänderungen von Minikube beachtet werden:
```shell
< DOCKER_CERT_PATH=/etc/docker
---
> if [ -z "${DOCKER_CERT_PATH}" ]; then
> DOCKER_CERT_PATH=/etc/docker
> fi
```
Denken Sie daran, `imagePullPolicy: Always` auszuschalten. Andernfalls verwendet Kubernetes keine lokal erstellten Images.
## Cluster verwalten
### Cluster starten
Mit dem Befehl `minikube start` können Sie Ihr Cluster starten.
Dieser Befehl erstellt und konfiguriert eine virtuelle Maschine, auf der ein Kubernetes-Cluster mit einem Knoten ausgeführt wird.
Ebenfalls konfiguriert dieser Befehl auch Ihre [kubectl](/docs/user-guide/kubectl-overview/) Installation zur Kommunikation mit diesem Cluster.
Wenn Sie sich hinter einem Web-Proxy befinden, müssen Sie diese Informationen mit dem Befehl `minikube start` übergeben:
```shell
https_proxy=<mein_proxy> minikube start --docker-env http_proxy=<mein_proxy> --docker-env https_proxy=<mein_proxy> --docker-env no_proxy=192.168.99.0/24
```
Leider wird nur das Setzen der Umgebungsvariablen nicht funktionieren.
Minikube erstellt auch einen "Minikube"-Kontext und setzt ihn in kubectl auf den Standardwert.
Um später wieder zu diesem Kontext zurückzukehren, führen Sie den folgenden Befehl aus: `kubectl config use-context minikube`.
#### Angabe der Kubernetes-Version
Sie können die bestimmte Version von Kubernetes für Minikube angeben, indem Sie die Zeichenfolge `--kubernetes-version` an den Befehl` minikube start` anhängen.
Zum Verwenden der Version `v1.7.3` führen Sie beispielsweise Folgendes aus:
```
minikube start --kubernetes-version v1.7.3
```
### Kubernetes konfigurieren
Minikube verfügt über eine "Konfigurator"-Funktion, mit der Anwender die Kubernetes-Komponenten mit beliebigen Werten konfigurieren können.
Um diese Funktion zu verwenden, setzen Sie das `--extra-config`-Flag an den `minikube start` Befehl.
Dieses Flag wird wiederholt, sodass Sie es mehrere Male mit verschiedenen Werten übergeben können, um mehrere Optionen festzulegen.
Dieses Flag nimmt eine Zeichenkette der Form `component.key=value` an, wobei `component` eine der Zeichenketten aus der unteren Liste ist, `key` ein Wert in der Konfigurationsstruktur ist und `value` der einzustellende Wert ist.
Gültige Schlüssel finden Sie in der Dokumentation der Kubernetes `componentconfigs` für jede Komponente.
Nachstehend die Dokumentation für jede unterstützte Konfiguration:
* [kubelet](https://godoc.org/k8s.io/kubernetes/pkg/kubelet/apis/config#KubeletConfiguration)
* [apiserver](https://godoc.org/k8s.io/kubernetes/cmd/kube-apiserver/app/options#ServerRunOptions)
* [proxy](https://godoc.org/k8s.io/kubernetes/pkg/proxy/apis/config#KubeProxyConfiguration)
* [controller-manager](https://godoc.org/k8s.io/kubernetes/pkg/controller/apis/config#KubeControllerManagerConfiguration)
* [etcd](https://godoc.org/github.com/coreos/etcd/etcdserver#ServerConfig)
* [scheduler](https://godoc.org/k8s.io/kubernetes/pkg/scheduler/apis/config#KubeSchedulerConfiguration)
#### Beispiele
Um die `MaxPods`-Einstellung im Kubelet auf 5 zu ändern, übergeben Sie dieses Flag: `--extra-config=kubelet.MaxPods=5`.
Diese Funktion unterstützt auch verschachtelte Strukturen. Um die `LeaderElection.LeaderElect` Einstellung zu `true` zu ändern, übergeben Sie im Scheduler dieses Flag: `--extra-config=scheduler.LeaderElection.LeaderElect=true`.
Um den `AuthorizationMode` auf dem `apiserver` zu `RBAC` zu ändern, verwenden Sie: `--extra-config=apiserver.authorization-mode=RBAC`.
### Einen Cluster stoppen
Mit dem Befehl `minikube stop` können Sie Ihr Cluster anhalten.
Mit diesem Befehl wird die Minikube Virtual Machine heruntergefahren, der Clusterstatus und die Clusterdaten bleiben jedoch erhalten.
Durch erneutes Starten des Clusters wird der vorherige Status wiederhergestellt.
### Cluster löschen
Der Befehl `minikube delete` kann zum Löschen Ihres Clusters verwendet werden.
Mit diesem Befehl wird die Minikube Virtual Machine heruntergefahren und gelöscht. Keine Daten oder Zustände bleiben erhalten.
## Mit einem Cluster interagieren
### Kubectl
Der `minikube start` Befehl erstellt einen [kubectl Kontext](/docs/reference/generated/kubectl/kubectl-commands#-em-set-context-em-) genannt "minikube".
Dieser Kontext enthält die Konfiguration für die Kommunikation mit Ihrem Minikube-Cluster.
Minikube setzt diesen Kontext automatisch auf den Standardwert, aber wenn Sie in Zukunft wieder darauf zurückgreifen müssen, führen Sie den folgenden Befehl aus:
`kubectl config use-context minikube`,
Oder übergeben Sie den Kontext bei jedem Befehl wie folgt: `kubectl get pods --context=minikube`.
### Dashboard
Um Zugriff auf das [Kubernetes Dashboard](/docs/tasks/access-application-cluster/web-ui-dashboard/) zu erhalten, führen Sie diesen Befehl in einer Shell aus, nachdem Sie Minikube gestartet haben, um die Adresse abzurufen:
```shell
minikube dashboard
```
### Services
Um auf einen Service zuzugreifen, der über einen NodePort verfügbar gemacht wird, führen Sie diesen Befehl in einer Shell aus, nachdem Sie Minikube gestartet haben, um die Adresse abzurufen:
```shell
minikube service [-n NAMESPACE] [--url] NAME
```
## Netzwerk
Die Minikube-VM wird über eine Host-Only-IP-Adresse, die mit dem Befehl `minikube ip` abgerufen werden kann, für das Hostsystem verfügbar gemacht.
Auf alle Dienste des Typs `NodePort` kann über diese IP-Adresse und den NodePort zugegriffen werden.
Um den NodePort für Ihren Dienst zu ermitteln, können Sie einen `kubectl`-Befehl wie folgt verwenden:
`kubectl get service $SERVICE --output='jsonpath="{.spec.ports[0].nodePort}"'`
## Dauerhafte Volumen
Minikube unterstützt [PersistentVolumes](/docs/concepts/storage/persistent-volumes/) des Typs `hostPath`.
Diese dauerhaften Volumen werden einem Verzeichnis in der Minikube-VM zugeordnet.
Die Minikube-VM wird in ein temporäres Dateisystem hochgefahren, sodass die meisten Verzeichnisse nicht nach Neustarts beibehalten werden (`minikube stop`).
Minikube ist jedoch so konfiguriert, dass Dateien beibehalten werden, die in den folgenden Host-Verzeichnissen gespeichert sind:
* `/data`
* `/var/lib/minikube`
* `/var/lib/docker`
Hier ist ein Beispiel einer PersistentVolume-Konfiguration, um Daten im Verzeichnis `/ data` beizubehalten:
```yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: pv0001
spec:
accessModes:
- ReadWriteOnce
capacity:
storage: 5Gi
hostPath:
path: /data/pv0001/
```
## Hostordnerfreigabe
Einige Treiber werden einen Hostordner in der VM bereitstellen, sodass Sie Dateien problemlos zwischen VM und Host freigeben können. Diese sind momentan nicht konfigurierbar und unterscheiden sich für den Treiber und das Betriebssystem, das Sie verwenden.
{{< note >}}
Die Hostordnerfreigabe ist noch nicht im KVM-Treiber implementiert.
{{< /note >}}
| Treiber | Betriebssystem | Hostordner | VM |
| --- | --- | --- | --- |
| VirtualBox | Linux | /home | /hosthome |
| VirtualBox | macOS | /Users | /Users |
| VirtualBox | Windows | C://Users | /c/Users |
| VMware Fusion | macOS | /Users | /Users |
| Xhyve | macOS | /Users | /Users |
## Private Containerregistries
Um auf eine private Container Registry zuzugreifen, führen Sie die Schritte [auf dieser Seite aus](/docs/concepts/containers/images/).
Wir empfehlen die Verwendung von `ImagePullSecrets`, wenn Sie jedoch den Zugriff auf die Minikube-VM konfigurieren möchten, können Sie die Datei `.dockercfg` im Verzeichnis`/home/docker` oder die Datei `config.json` im Verzeichnis`/home/docker/.docker` ablegen.
## Add-ons
Damit Minikube benutzerdefinierte Addons ordnungsgemäß starten oder neu starten kann, platzieren Sie die Addons, die mit Minikube gestartet werden sollen, im Verzeichnis `~ /.minikube/addons`.
Addons in diesem Ordner werden in die Minikube-VM verschoben und jedes Mal gestartet, wenn Minikube gestartet oder neu gestartet wird.
## Minikube mit einem HTTP-Proxy verwenden
Minikube erstellt eine virtuelle Maschine, die Kubernetes und einen Docker-Dämon enthält.
Wenn Kubernetes versucht, Container mithilfe von Docker zu planen, erfordert der Docker-Daemon möglicherweise einen externen Netzwerkzugriff, um Container abzurufen.
Wenn Sie sich hinter einem HTTP-Proxy befinden, müssen Sie möglicherweise die Proxy-Einstellungen für Docker angeben.
Übergeben Sie dazu die erforderlichen Umgebungsvariablen während des `minikube start` als Flags.
Zum Beispiel:
```shell
minikube start --docker-env http_proxy=http://$IHRPROXY:PORT \
--docker-env https_proxy=https://$IHRPROXY:PORT
```
Wenn die Adresse Ihrer virtuellen Maschine 192.168.99.100 lautet, besteht die Möglichkeit, dass Ihre Proxy-Einstellungen verhindern, dass `kubectl` sie direkt erreicht.
Um die Proxy-Konfiguration für diese IP-Adresse zu umgehen, sollten Sie Ihre no_proxy-Einstellungen ändern. Sie können dies mit dem folgenden Befehl tun:
```shell
export no_proxy=$no_proxy,$(minikube ip)
```
## Bekannte Probleme
* Funktionen, die einen Cloud-Provider erfordern, funktionieren in Minikube nicht. Diese schließen ein:
* LoadBalancer
* Features, die mehrere Knoten erfordern. Diese schließen ein:
* Erweiterte Planungsrichtlinien
## Design
Minikube verwendet [libmachine](https://github.com/docker/machine/tree/master/libmachine) zur Bereitstellung von VMs, und [kubeadm](https://github.com/kubernetes/kubeadm) um einen Kubernetes-Cluster in Betrieb zu nehmen.
Weitere Informationen zu Minikube finden Sie im [Vorschlag](https://git.k8s.io/community/contributors/design-proposals/cluster-lifecycle/local-cluster-ux.md).
## Zusätzliche Links
* **Ziele und Nichtziele**: Die Ziele und Nichtziele des Minikube-Projekts finden Sie in unserer [Roadmap](https://git.k8s.io/minikube/docs/contributors/roadmap.md).
* **Entwicklungshandbuch**: Lesen Sie [CONTRIBUTING.md](https://git.k8s.io/minikube/CONTRIBUTING.md) für einen Überblick über das Senden von Pull-Requests.
* **Minikube bauen**: Anweisungen zum Erstellen/Testen von Minikube aus dem Quellcode finden Sie im [build Handbuch](https://git.k8s.io/minikube/docs/contributors/build_guide.md).
* **Neue Abhängigkeit hinzufügen**: Anweisungen zum Hinzufügen einer neuen Abhängigkeit zu Minikube finden Sie in der [Anleitung zum Hinzufügen von Abhängigkeiten](https://git.k8s.io/minikube/docs/contributors/adding_a_dependency.md).
* **Neues Addon hinzufügen**: Anweisungen zum Hinzufügen eines neuen Addons für Minikube finden Sie im [Anleitung zum Hinzufügen eines Addons](https://git.k8s.io/minikube/docs/contributors/adding_an_addon.md).
* **MicroK8s**: Linux-Benutzer, die die Ausführung einer virtuellen Maschine vermeiden möchten, sollten [MicroK8s](https://microk8s.io/) als Alternative in Betracht ziehen.
## Community
Beiträge, Fragen und Kommentare werden begrüßt und ermutigt! Minikube-Entwickler finden Sie in [Slack](https://kubernetes.slack.com) im #minikube Kanal (Erhalten Sie [hier](http://slack.kubernetes.io/) eine Einladung). Wir haben ausserdem die [kubernetes-dev Google Groups-Mailingliste](https://groups.google.com/forum/#!forum/kubernetes-dev). Wenn Sie in der Liste posten, fügen Sie Ihrem Betreff bitte "minikube:" voran.
{{% /capture %}}

4
content/de/docs/setup/on-permises-vm/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: Lokale VMs
weight: 60
---

5
content/de/docs/setup/release/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Kubernetes herunterladen"
weight: 20
---

32
content/de/docs/setup/release/building-from-source.md Normal file
View File

@ -0,0 +1,32 @@
---
title: Release erstellen
content_template: templates/concept
card:
name: download
weight: 20
title: Release erstellen
---
{{% capture overview %}}
Sie können entweder eine Version aus dem Quellcode erstellen oder eine bereits kompilierte Version herunterladen.
Wenn Sie nicht vorhaben, Kubernetes selbst zu entwickeln, empfehlen wir die Verwendung eines vorkompilierten Builds der aktuellen Version, die Sie in den [Versionshinweisen](/docs/setup/release/notes/) finden.
Der Kubernetes-Quellcode kann aus dem [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes) repo der heruntergeladen werden.
{{% /capture %}}
{{% capture body %}}
## Aus dem Quellcode kompilieren
Wenn Sie einfach ein Release aus dem Quellcode erstellen, müssen Sie keine vollständige Golang-Umgebung einrichten, da alle Aktionen in einem Docker-Container stattfinden.
Das Kompilieren einer Version ist einfach:
```shell
git clone https://github.com/kubernetes/kubernetes.git
cd kubernetes
make release
```
Mehr Informationen zum Release-Prozess finden Sie im kubernetes/kubernetes [`build`](http://releases.k8s.io/{{< param "githubbranch" >}}/build/) Verzeichnis.
{{% /capture %}}

4
content/de/docs/setup/turnkey/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: Schlüsselfertige Cloud-Lösungen
weight: 40
---

0
content/en/docs/setup/windows/_index.md → content/de/docs/setup/windows/_index.md
View File

114
content/de/docs/sitemap.md Normal file
View File

@ -0,0 +1,114 @@
---
---
<script language="JavaScript">
var dropDownsPopulated = false;
$( document ).ready(function() {
// When the document loads, get the metadata JSON, and kick off tbl render
$.get("/metadata.txt", function(data, status) {
metadata = $.parseJSON(data);
metadata.pages.sort(dynamicSort("t"));
mainLogic()
$(window).bind( 'hashchange', function(e) {
mainLogic();
});
});
});
function mainLogic()
{
// If there's a tag filter, change the table/drop down output
if (!dropDownsPopulated) populateDropdowns();
var tag=window.location.hash.replace("#","");
if(tag) {
tag = $.trim(tag);
for (i=0;i<tagName.length;i++) {
querystringTag = tagName[i] + "=";
if (tag.indexOf(querystringTag) > -1)
{
console.log("in mainLog: querystringTag of " + querystringTag + " matches tag of " + tag);
tag = tag.replace(querystringTag,"");
selectDropDown(tagName[i],tag);
topicsFilter(tagName[i],tag,"output");
}
}
} else {
currentTopics = metadata.pages;
}
renderTable(currentTopics,"output");
}
function populateDropdowns()
{
// Keeping mainLogic() brief by functionalizing the initialization of the
// drop-down filter boxes
for(i=0;i<metadata.pages.length;i++)
{
var metadataArrays = [metadata.pages[i].cr,metadata.pages[i].or,metadata.pages[i].mr];
for(j=0;j<metadataArrays.length;j++)
{
if (metadataArrays[j]) {
for (k=0;k<metadataArrays[j].length;k++) {
if (typeof storedTagsArrays[j] == 'undefined') storedTagsArrays[j] = new Array();
storedTagsArrays[j][metadataArrays[j][k][tagName[j]]] = true;
// ^ conceptList[metadata.pages[i].cr[k].concept] = true; (if rolling through concepts)
// ^ conceptList['container'] = true; (ultimate result)
// ^ objectList[metadata.pages[i].or[k].object] = true; (if rolling through objects)
// ^ objectList['restartPolicy'] = true; (ultimate result)
}
}
}
}
var output = new Array();
for(i=0;i<tagName.length;i++)
{
// Phew! All tags in conceptList, objectList, and commandList!
// Loop through them and populate those drop-downs through html() injection
output = [];
output.push("<select id='" + tagName[i] + "' onchange='dropFilter(this)'>");
output.push("<option>---</option>");
Object.keys(storedTagsArrays[i]).sort().forEach(function (key) {
output.push("<option>" + key + "</option>");
});
output.push("</select>")
$(dropDowns[i]).html(output.join(""));
}
dropDownsPopulated = true;
}
function dropFilter(srcobj)
{
// process the change of a drop-down value
// the ID of the drop down is either command, object, or concept
// these exact values are what topicsFilter() expects, plus a filter val
// which we get from .text() of :selected
console.log("dropFilter:" + $(srcobj).attr('id') + ":" + $(srcobj).find(":selected").text());
topicsFilter($(srcobj).attr('id').replace("#",""),$(srcobj).find(":selected").text(),"output");
for(i=0;i<tagName.length;i++)
{
if($(srcobj).attr('id')!=tagName[i]) selectDropDown(tagName[i],"---");
}
}
function selectDropDown(type,tag)
{
// change drop-down selection w/o filtering
$("#" + type).val(tag);
}
</script>
<style>
#filters select{
font-size: 14px;
border: 1px #000 solid;
}
#filters {
padding-top: 20px;
}
</style>
Klicken Sie auf Tags oder verwenden Sie die Dropdown-Liste zum Filtern. Klicken Sie auf Tabellenköpfe, um die Ergebnisse zu sortieren oder umzukehren.
<p id="filters">
Nach Konzept filtern: <span id="conceptFilter" /><br/>
Nach Objekt filtern: <span id="objectFilter" /><br/>
Nach Befehl filtern: <span id="commandFilter" />
</p>
<div id="output" />

85
content/de/docs/tasks/_index.md Normal file
View File

@ -0,0 +1,85 @@
---
title: Aufgaben
main_menu: true
weight: 50
content_template: templates/concept
---
{{< toc >}}
{{% capture overview %}}
Dieser Abschnitt der Kubernetes-Dokumentation enthält Seiten, die zeigen, wie man einzelne Aufgaben erledigt.
Eine Aufgabenseite zeigt, wie man eine einzelne Aufgabe ausführt, typischerweise durch eine kurze Abfolge von Schritten.
{{% /capture %}}
{{% capture body %}}
## Webbenutzeroberfläche (Dashboard)
Stellen Sie die Dashboard-Webbenutzeroberfläche bereit, und greifen Sie auf sie zu, um Sie bei der Verwaltung und Überwachung von Containeranwendungen in einem Kubernetes-Cluster zu unterstützen.
## Die kubectl-Befehlszeile verwenden
Installieren und konfigurieren Sie das `kubectl`-Befehlszeilentool, mit dem Kubernetes-Cluster direkt verwaltet werden.
## Pods und Container konfigurieren
Ausführen allgemeiner Konfigurationsaufgaben für Pods und Container.
## Anwendungen ausführen
Ausführen allgemeiner Aufgaben zur Anwendungsverwaltung, z. B. Aktualisierungen, Einfügen von Informationen in Pods und automatisches horizontales Skalieren der Pods.
## Jobs ausführen
Jobs mit Parallelverarbeitung ausführen.
## Auf Anwendungen in einem Cluster zugreifen
Konfigurieren Sie den Lastausgleich, die Portweiterleitung oder die Einrichtung von Firewall- oder DNS-Konfigurationen für den Zugriff auf Anwendungen in einem Cluster.
## Überwachung, Protokollierung und Fehlerbehebung
Richten Sie die Überwachung und Protokollierung ein, um einen Cluster zu behandeln oder eine Container-Anwendung zu debuggen.
## Zugriff auf die Kubernetes-API
Lernen Sie verschiedene Methoden kennen, um direkt auf die Kubernetes-API zuzugreifen.
## TLS verwenden
Konfigurieren Sie Ihre Anwendung so, dass sie der Cluster-Stammzertifizierungsstelle (Certificate Authority, CA) vertraut und diese verwendet.
## Cluster verwalten
Erfahren Sie allgemeine Aufgaben zum Verwalten eines Clusters.
## Föderation verwalten
Konfigurieren Sie Komponenten in einer Clusterföderation.
## Managing Stateful Applications
Ausführen allgemeiner Aufgaben zum Verwalten von Stateful-Anwendungen, einschließlich Skalieren, Löschen und Debuggen von StatefulSets.
## Cluster-Dämonen
Ausführen allgemeiner Aufgaben zum Verwalten eines DaemonSet, z. B. Durchführen eines fortlaufenden Updates.
## GPUs verwalten
Konfigurieren und planen Sie NVIDIA-GPUs für die Verwendung durch Nodes in einem Cluster als Ressource.
## Verwalten von HugePages
Konfigurieren und verwalten Sie `HugePages` als planbare Ressource in einem Cluster.
{{% /capture %}}
{{% capture whatsnext %}}
Wenn Sie eine Aufgabenseite schreiben möchten, finden Sie weitere Informationen unter [Erstellen einer Pull-Anfrage für Dokumentation](/docs/home/contribute/create-pull-request/).
{{% /capture %}}

5
content/de/docs/tasks/access-application-cluster/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Auf Anwendungen in einem Cluster zugreifen"
weight: 60
---

5
content/de/docs/tasks/access-kubernetes-api/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Kubernetes erweitern"
weight: 90
---

5
content/de/docs/tasks/administer-cluster/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Einen Cluster verwalten"
weight: 20
---

5
content/de/docs/tasks/configure-pod-container/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Pods und Container konfigurieren"
weight: 20
---

5
content/de/docs/tasks/debug-application-cluster/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Überwachung, Protokollierung und Fehlerbehebung"
weight: 80
---

5
content/de/docs/tasks/federation/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Föderation"
weight: 120
---

5
content/de/docs/tasks/inject-data-application/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Daten in Anwendungen injizieren"
weight: 30
---

5
content/de/docs/tasks/job/_index.md Normal file
View File

@ -0,0 +1,5 @@
---
title: "Jobs ausführen"
weight: 50
---

5
content/de/docs/tasks/manage-daemon/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Cluster-Daemons verwalten"
weight: 130
---

5
content/de/docs/tasks/run-application/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Anwendungen ausführen"
weight: 40
---

171
content/de/docs/tasks/run-application/horizontal-pod-autoscale.md Normal file
View File

@ -0,0 +1,171 @@
---
title: Horizontal Pod Autoscaler
feature:
title: Horizontales Skalieren
description: >
Skaliere deine Anwendung mit einem einfachen Befehl, über die Benutzeroberfläche oder automatisch, basierend auf der CPU-Auslastung.
content_template: templates/concept
weight: 90
---
{{% capture overview %}}
Der Horizontal Pod Autoscaler skaliert automatisch die Anzahl der Pods eines Replication Controller, Deployment oder Replikat Set basierend auf der beobachteten CPU-Auslastung (oder, mit Unterstützung von [benutzerdefinierter Metriken](https://git.k8s.io/community/contributors/design-proposals/instrumentation/custom-metrics-api.md), von der Anwendung bereitgestellten Metriken). Beachte, dass die horizontale Pod Autoskalierung nicht für Objekte gilt, die nicht skaliert werden können, z. B. DaemonSets.
Der Horizontal Pod Autoscaler ist als Kubernetes API-Ressource und einem Controller implementiert.
Die Ressource bestimmt das Verhalten des Controllers.
Der Controller passt die Anzahl der Replikate eines Replication Controller oder Deployments regelmäßig an, um die beobachtete durchschnittliche CPU-Auslastung an das vom Benutzer angegebene Ziel anzupassen.
{{% /capture %}}
{{% capture body %}}
## Wie funktioniert der Horizontal Pod Autoscaler?
![Horizontal Pod Autoscaler Diagramm](/images/docs/horizontal-pod-autoscaler.svg)
Der Horizontal Pod Autoscaler ist als Kontrollschleife mit einer Laufzeit implementiert, die durch das Flag `--horizontal-pod-autoscaler-sync-period` am Controller Manager gesteuert wird (mit einem Standardwert von 15 Sekunden).
Während jedem Durchlauf fragt der Controller Manager die Ressourcennutzung anhand der in jeder HorizontalPodAutoscaler Definition angegebenen Metriken ab. Der Controller Manager bezieht die Metriken entweder aus der Resource Metrics API (für Ressourcenmetriken pro Pod) oder aus der Custom Metrics API (für alle anderen Metriken).
* Für jede pro Pod Ressourcenmetriken (wie CPU) ruft der Controller die Metriken über die Ressourcenmetriken API für jeden Pod ab, der vom HorizontalPodAutoscaler angesprochen wird. Sofern ein Zielnutzungswert eingestellt ist, berechnet der Controller den Nutzungswert als Prozentsatz der äquivalenten Ressourcenanforderung der Containern in jedem Pod. Wenn ein Ziel-Rohwert eingestellt ist, werden die Rohmetrikenwerte direkt verwendet. Der Controller nimmt dann den Mittelwert der Auslastung oder den Rohwert (je nach Art des angegebenen Ziels) über alle Zielpods und erzeugt ein Quotienten, mit dem die Anzahl der gewünschten Replikate skaliert wird.
Beachte, dass, wenn einige der Container des Pods nicht über den entsprechenden Ressourcenanforderung verfügen, die CPU-Auslastung für den Pod nicht definiert wird und der Autoscaler keine Maßnahmen bezüglich dieser Metrik ergreift. Weitere Informationen zur Funktionsweise des Autoskalierungsalgorithmus finden Sie im folgenden Abschnitt über den [Algorithmus](#details-zum-algorithmus).
* Bei benutzerdefinierten Metriken pro Pod funktioniert die Steuerung ähnlich wie bei Ressourcenmetriken pro Pod, nur dass diese mit Rohwerten und nicht mit Nutzungswerten arbeitet.
* Für Objektmetriken und externe Metriken wird eine einzelne Metrik abgerufen, die das jeweilige Objekt beschreibt. Diese Kennzahl wird mit dem Sollwert verglichen, um ein Verhältnis wie oben beschrieben zu erhalten. In der API-Version von `autoscaling/v2beta2` kann dieser Wert optional durch die Anzahl der Pods geteilt werden, bevor der Vergleich durchgeführt wird.
Der HorizontalPodAutoscaler holt Metriken normalerweise aus einer Reihe von aggregierten APIs (`metrics.k8s.io`, `custom.metrics.k8s.io` und `external.metrics.k8s.io`). Die API `metrics.k8s.io` wird normalerweise vom Metrics Server bereitgestellt, der separat gestartet werden muss. Siehe [Metrics Server](/docs/tasks/debug-application-cluster/resource-metrics-pipeline/#metrics-server) für weitere Anweisungen. Der HorizontalPodAutoscaler kann auch Metriken direkt aus dem Heapster beziehen.
{{< note >}}
{{< feature-state state="deprecated" for_k8s_version="1.11" >}}
Das Verwenden von Metriken aus Heapster ist seit der Kubernetes Version 1.11 veraltet.
{{< /note >}}
Siehe [Unterstützung der Metrik APIs](#unterstützung-der-metrik-apis) für weitere Details.
Der Autoscaler greift über die Scale Sub-Ressource auf die entsprechenden skalierbaren Controller (z.B. Replication Controller, Deployments und Replika Sets) zu. Scale ist eine Schnittstelle, mit der Sie die Anzahl der Replikate dynamisch einstellen und jeden ihrer aktuellen Zustände untersuchen können. Weitere Details zu der Scale Sub-Ressource findest du [hier](https://git.k8s.io/community/contributors/design-proposals/autoscaling/horizontal-pod-autoscaler.md#scale-subresource).
### Details zum Algorithmus
Vereinfacht gesagt arbeitet der Horizontal Pod Autoscaler Controller mit dem Verhältnis zwischen dem gewünschten metrischen Wert und dem aktuellen metrischen Wert:
```
desiredReplicas = ceil[currentReplicas * ( currentMetricValue / desiredMetricValue )]
```
Wenn beispielsweise der aktuelle metrische Wert `200m` und der gewünschte Wert `100m` ist, wird die Anzahl der Replikate verdoppelt, da `200.0 / 100.0 == 2.0` ist. Wenn der aktuelle Wert jedoch `50m` ist, halbieren sich die Anzahl der Replikate `50.0 / 100.0 == 0.5`. Es wird auf die Skalierung verzichtet, wenn das Verhältnis ausreichend nahe bei 1,0 liegt (innerhalb einer global konfigurierbaren Toleranz, vom Flag `--horizontal-pod-autoscaler-tolerance`, das standardmäßig auf 0,1 gesetzt ist).
Wenn ein `targetAverageValue` oder `targetAverageUtilization` angegeben wird, wird der `currentMetricValue` berechnet, indem der Mittelwert der gegebenen Metrik über alle Pods im Skalierungsziel des HorizontalPodAutoscaler berechnet wird. Vor der Überprüfung der Toleranz und der Entscheidung über die finalen Werte berücksichtigen wir jedoch die Pod Readiness und fehlende Metriken.
Alle Pods mit einem gesetzten Zeitstempel zur Löschung (d.h. Pods, die gerade heruntergefahren werden) und alle ausgefallenen Pods werden verworfen.
Wenn einem bestimmten Pod Metriken fehlen, wird es für später zurückgestellt; Pods mit fehlenden Metriken werden verwendet, um den endgültigen Skalierungsmenge anzupassen.
Wenn bei der Skalierung anhand der CPU ein Pod noch nicht bereit ist (d.h. er wird noch initialisiert) *oder* der letzte metrische Punkt für den Pod vor dessen Einsatzbereitschaft liegt, wird auch dieser Pod zurückgestellt.
Aufgrund technischer Einschränkungen kann der HorizontalPodAutoscaler Controller nicht genau bestimmen, wann ein Pod zum ersten Mal bereit ist, wenn es darum geht, bestimmte CPU Metriken festzulegen. Stattdessen betrachtet er eine Pod als "not yet ready", wenn dieser noch nicht bereit ist und geht in "unready" über, innerhalb eines kurzen, konfigurierbaren Zeitfensters seit dem Start.
Dieser Wert wird mit dem Flag `--horizontal-pod-autoscaler-initial-readiness-delay` konfiguriert und ist standardmäßig auf 30 Sekunden eingestellt. Sobald ein Pod bereit ist, betrachtet er jeden Übergang zu Bereit als den ersten, wenn dies innerhalb einer längeren, konfigurierbaren Zeit seit seinem Start erfolgt ist. Dieser Wert wird mit dem Flag `--horizontal-pod-autoscaler-cpu-initialization-period` gesetzt und dessen Standardwert beträgt 5 Minuten.
Das Basisskalenverhältnis `currentMetricValue / desiredMetricValue` wird dann mit den restlichen Pods berechnet, die nicht zurückgestellt oder von den oben genannten Kriterien entsorgt wurden.
Wenn es irgendwelche fehlenden Metriken gab, berechnen wir den Durchschnitt konservativer, vorausgesetzt, dass die Pods 100% des gewünschten Wertes bei der Verringerung und 0% bei einer Vergrößerung verbrauchten. Dadurch wird die Dimension einer beliebigen potenziellen Skalierung verringert.
Wenn außerdem noch nicht bereite Pods vorhanden sind und es ohne Berücksichtigung fehlender Metriken oder noch nicht bereiter Pods skaliert wurde, wird konservativ davon ausgegangen, dass die noch nicht bereiten Pods 0% der gewünschten Metrik verbrauchen, was die Dimension einer Skalierung weiter dämpft.
Nach Berücksichtigung der noch nicht bereiten Pods und fehlender Metriken wird der Nutzungsgrad neu berechnet. Wenn das neue Verhältnis die Skalierungsrichtung umkehrt oder innerhalb der Toleranz liegt, wird das weitere Skalieren übersprungen. Andernfalls wird das neue Verhältnis zur Skalierung verwendet.
Beachte, dass der *ursprüngliche* Wert für die durchschnittliche Auslastung über den HorizontalPodAutoscaler Status zurückgemeldet wird, ohne die noch nicht bereiten Pods oder fehlende Metriken zu berücksichtigen, selbst wenn das neue Nutzungsverhältnis verwendet wird.
Wenn mehrere Metriken in einem HorizontalPodAutoscaler angegeben sind, wird die Berechnung für jede Metrik durchgeführt, und dann wird die größte der gewünschten Replikanzahl ausgewählt. Wenn eine dieser Metriken nicht in eine gewünschte Replikanzahl umgewandelt werden kann (z.B. aufgrund eines Fehlers beim Abrufen der Metriken aus den Metrik APIs), wird diese Skalierung übersprungen.
Schließlich, kurz bevor HPA das Ziel skaliert, wird die Skalierungsempfehlung aufgezeichnet. Der Controller berücksichtigt alle Empfehlungen innerhalb eines konfigurierbaren Fensters und wählt aus diesem Fenster die höchste Empfehlung aus. Dieser Wert kann mit dem Flag `--horizontal-pod-autoscaler-downscale-stabilization` konfiguriert werden, das standardmäßig auf 5 Minuten eingestellt ist. Dies bedeutet, dass die Skalierung schrittweise erfolgt, wodurch die Auswirkungen schnell schwankender metrischer Werte ausgeglichen werden.
## API Objekt
Der Horizontal Pod Autoscaler ist eine API Ressource in der Kubernetes `autoscaling` API Gruppe.
Die aktuelle stabile Version, die nur die Unterstützung für die automatische Skalierung der CPU beinhaltet, befindet sich in der `autoscaling/v1` API Version.
Die Beta-Version, weclhe die Skalierung des Speichers und benutzerdefinierte Metriken unterstützt, befindet sich unter `autoscaling/v2beta2`. Die in `autoscaling/v2beta2` neu eingeführten Felder bleiben bei der Arbeit mit `autoscaling/v1` als Anmerkungen erhalten.
Weitere Details über das API Objekt kann unter dem [HorizontalPodAutoscaler Objekt](https://git.k8s.io/community/contributors/design-proposals/autoscaling/horizontal-pod-autoscaler.md#horizontalpodautoscaler-object) gefunden werden.
## Unterstützung des Horizontal Pod Autoscaler in kubectl
Der Horizontal Pod Autoscaler wird, wie jede API-Ressource, standardmäßig von `kubectl` unterstützt.
Ein neuer Autoskalierer kann mit dem Befehl `kubectl create` erstellt werden.
Das auflisten der Autoskalierer geschieht über `kubectl get hpa` und eine detaillierte Beschreibung erhält man mit `kubectl describe hpa`.
Letzendlich können wir einen Autoskalierer mit `kubectl delete hpa` löschen.
Zusätzlich gibt es einen speziellen Befehl `kubectl autoscale` zur einfachen Erstellung eines Horizontal Pod Autoscalers.
Wenn du beispielsweise `kubectl autoscale rs foo --min=2 --max=5 --cpu-percent=80` ausführst, wird ein Autoskalierer für den Replication Set *foo* erstellt, wobei die Ziel-CPU-Auslastung auf `80%` und die Anzahl der Replikate zwischen 2 und 5 gesetzt wird.
Die Detaildokumentation von `kubectl autoscale` kann [hier](/docs/reference/generated/kubectl/kubectl-commands/#autoscale) gefunden werden.
## Autoskalieren während rollierender Updates
Derzeit ist es in Kubernetes möglich, ein [rollierendes Update](/docs/tasks/run-application/rolling-update-replication-controller/) durchzuführen, indem du den Replikationscontroller direkt verwaltest oder das Deployment Objekt verwendest, das die zugrunde liegenden Replica Sets für dich verwaltet.
Der Horizontal Pod Autoscaler unterstützt nur den letztgenannten Ansatz: Der Horizontal Pod Autoscaler ist an das Deployment Objekt gebunden, er legt die Größe für das Deployment Objekt fest, und das Deployment ist für die Festlegung der Größen der zugrunde liegenden Replica Sets verantwortlich.
Der Horizontal Pod Autoscaler funktioniert nicht mit rollierendem Update durch direkte Manipulation vom Replikationscontrollern, d.h. du kannst einen Horizontal Pod Autoscaler nicht an einen Replikationscontroller binden und rollierend aktualisieren (z.B. mit `kubectl rolling-update`).
Der Grund dafür ist, dass beim Erstellen eines neuen Replikationscontrollers durch ein rollierendes Update der Horizontal Pod Autoscaler nicht an den neue Replikationscontroller gebunden wird.
## Unterstützung von Abklingzeiten/Verzögerungen
Bei der Verwaltung der Größe einer Gruppe von Replikaten mit dem Horizontal Pod Autoscaler ist es möglich, dass die Anzahl der Replikate aufgrund der Dynamik der ausgewerteten Metriken häufig schwankt. Dies wird manchmal als *thrashing*, zu deutsch *Flattern*, bezeichnet.
Ab v1.6 kann ein Cluster Operator dieses Problem mitigieren, indem er die globalen HPA Einstellungen anpasst, die als Flags für die Komponente `kube-controller-manager` dargelegt werden:
Ab v1.12 erübrigt ein neues Update des Algorithmus die Notwendigkeit der Verzögerung beim hochskalieren.
- `--horizontal-pod-autoscaler-downscale-stabilization`: Der Wert für diese Option ist eine Dauer, die angibt, wie lange der Autoscaler warten muss, bis nach Abschluss des aktuellen Skalierungsvorgangs ein weiterer Downscale durchgeführt werden kann.
Der Standardwert ist 5 Minuten (`5m0s`).
{{< note >}}
Beim Abstimmen dieser Parameterwerte sollte sich ein Clusterbetreiber der möglichen Konsequenzen bewusst sein. Wenn der Wert für die Verzögerung (Abklingzeit) zu groß eingestellt ist, kann es zu Beschwerden kommen, dass der Horizontal Pod Autoscaler nicht auf Änderungen der Arbeitslast reagiert. Wenn der Verzögerungswert jedoch zu kurz eingestellt ist, kann es vorkommen, dass die Skalierung der eingestellten Replikate wie gewohnt weiter flattert.
{{< /note >}}
## Unterstützung von mehrere Metriken
Kubernetes 1.6 bietet Unterstützung für die Skalierung basierend auf mehreren Metriken. Du kannst die API Version `autoscaling/v2beta2` verwenden, um mehrere Metriken für den Horizontal Pod Autoscaler zum Skalieren festzulegen. Anschließend wertet der Horizontal Pod Autoscaler Controller jede Metrik aus und schlägt eine neue Skalierung basierend auf diesen Metrik vor. Die größte der vorgeschlagenen Skalierung wird als neue Skalierung verwendet.
## Unterstützung von benutzerdefinierte Metriken
{{< note >}}
Kubernetes 1.2 bietet Alpha Unterstützung für die Skalierung basierend auf anwendungsspezifischen Metriken über speziellen Annotations. Die Unterstützung für diese Annotations wurde in Kubernetes 1.6 zugunsten der neuen autoskalierenden API entfernt. Während die alte Methode zum Sammeln von benutzerdefinierten Metriken weiterhin verfügbar ist, stehen diese Metriken dem Horizontal Pod Autoscaler nicht mehr zur Verfügung, ebenso wenig wie die früheren Annotations zur Angabe, welche benutzerdefinierten Metriken zur Skalierung vom Horizontal Pod Autoscaler Controller berücksichtigt werden sollen.
{{< /note >}}
Kubernetes 1.6 bietet Unterstützung für die Verwendung benutzerdefinierter Metriken im Horizontal Pod Autoscaler.
Du kannst benutzerdefinierte Metriken für den Horizontal Pod Autoscaler hinzufügen, die in der `autoscaling/v2beta2` API verwendet werden.
Kubernetes fragt dann die neue API für die benutzerdefinierte Metriken ab, um die Werte der entsprechenden benutzerdefinierten Metriken zu erhalten.
Die Voraussetzungen hierfür werden im nachfolgenden Kapitel [Unterstützung für die Metrik APIs](#unterstützung-der-metrik-apis) geklärt.
## Unterstützung der Metrik APIs
Standardmäßig ruft der HorizontalPodAutoscaler Controller Metriken aus einer Reihe von APIs ab. Damit dieser auf die APIs zugreifen kann, muss der Cluster Administratoren sicherstellen, dass:
* Der [API Aggregations Layer](/docs/tasks/access-kubernetes-api/configure-aggregation-layer/) aktiviert ist.
* Die entsprechenden APIs registriert sind:
* Für Ressourcenmetriken ist dies die API `metrics.k8s.io`, die im Allgemeinen von [metrics-server](https://github.com/kubernetes-incubator/metrics-server) bereitgestellt wird.
Es kann als Cluster-Addon gestartet werden.
* Für benutzerdefinierte Metriken ist dies die API `custom.metrics.k8s.io`. Diese wird vom "Adapter" API Servern bereitgestellt, welches von Anbietern von Metrik Lösungen beliefert wird.
Überprüfe dies mit deiner Metrik Pipeline oder der [Liste bekannter Lösungen](https://github.com/kubernetes/metrics/blob/master/IMPLEMENTATIONS.md#custom-metrics-api).
Falls du deinen eigenen schreiben möchtest hilft dir folgender [boilerplate](https://github.com/kubernetes-incubator/custom-metrics-apiserver) um zu starten.
* Für externe Metriken ist dies die `external.metrics.k8s.io` API. Es kann sein, dass dies durch den benutzerdefinierten Metrik Adapter bereitgestellt wird.
* Das Flag `--horizontal-pod-autoscaler-use-rest-clients` ist auf `true` oder ungesetzt. Wird dies auf `false` gesetzt wird die Heapster basierte Autoskalierung aktiviert, welche veraltet ist.
{{% /capture %}}
{{% capture whatsnext %}}
* Design Dokument [Horizontal Pod Autoscaling](https://git.k8s.io/community/contributors/design-proposals/autoscaling/horizontal-pod-autoscaler.md).
* kubectl autoscale Befehl: [kubectl autoscale](/docs/reference/generated/kubectl/kubectl-commands/#autoscale).
* Verwenden des [Horizontal Pod Autoscaler](/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/).
{{% /capture %}}

5
content/de/docs/tasks/service-catalog/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Service Catalog installieren"
weight: 150
---

5
content/de/docs/tasks/tls/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "TLS"
weight: 100
---

5
content/de/docs/tasks/tools/_index.md Executable file
View File

@ -0,0 +1,5 @@
---
title: "Werkzeuge installieren"
weight: 10
---

429
content/de/docs/tasks/tools/install-kubectl.md Normal file
View File

@ -0,0 +1,429 @@
---
title: Installieren und konfigurieren von kubectl
content_template: templates/task
weight: 10
card:
name: tasks
weight: 20
title: Kubectl installieren
---
{{% capture overview %}}
Verwenden Sie das Kubernetes Befehlszeilenprogramm, [kubectl](/docs/user-guide/kubectl/), um Anwendungen auf Kubernetes bereitzustellen und zu verwalten.
Mit kubectl können Sie Clusterressourcen überprüfen, Komponenten erstellen, löschen und aktualisieren; Ihren neuen Cluster betrachten; und Beispielanwendungen aufrufen.
{{% /capture %}}
{{% capture prerequisites %}}
Sie müssen eine kubectl-Version verwenden, die innerhalb eines geringfügigen Versionsunterschieds zur Version Ihres Clusters liegt. Ein v1.2-Client sollte beispielsweise mit einem v1.1, v1.2 und v1.3-Master arbeiten. Die Verwendung der neuesten Version von kubectl verhindert unvorhergesehene Probleme.
{{% /capture %}}
{{% capture steps %}}
## Kubectl installieren
Nachfolgend finden Sie einige Methoden zur Installation von kubectl.
## Installieren der kubectl Anwendung mithilfe der systemeigenen Paketverwaltung
{{< tabs name="kubectl_install" >}}
{{< tab name="Ubuntu, Debian oder HypriotOS" codelang="bash" >}}
sudo apt-get update && sudo apt-get install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl
{{< /tab >}}
{{< tab name="CentOS, RHEL oder Fedora" codelang="bash" >}}cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF
yum install -y kubectl
{{< /tab >}}
{{< /tabs >}}
## Installation mit snap auf Ubuntu
Wenn Sie Ubuntu oder eine der anderen Linux-Distributionen verwenden, die den [snap](https://snapcraft.io/docs/core/install) Paketmanager unterstützen, können Sie kubectl als [snap](https://snapcraft.io/)-Anwendung installieren.
1. Wechseln Sie zum Snap-Benutzer und führen Sie den Installationsbefehl aus:
```
sudo snap install kubectl --classic
```
2. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
## Installation mit Homebrew auf macOS
Wenn Sie mit macOS arbeiten und den [Homebrew](https://brew.sh/) Paketmanager verwenden, können Sie kubectl mit Homebrew installieren.
1. Führen Sie den Installationsbefehl aus:
```
brew install kubernetes-cli
```
2. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
## Installation mit Macports auf macOS
Wenn Sie mit macOS arbeiten und den [Macports](https://macports.org/) Paketmanager verwenden, können Sie kubectl mit Macports installieren.
1. Führen Sie den Installationsbefehl aus:
```
sudo port selfupdate
sudo port install kubectl
```
2. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
## Installation mit PowerShell von PSGallery
Wenn Sie mit Windows arbeiten und den [Powershell Gallery](https://www.powershellgallery.com/) Paketmanager verwenden, können Sie kubectl mit Powershell installieren und aktualisieren.
1. Führen Sie die Installationsbefehle aus (stellen Sie sicher, dass eine `DownloadLocation` angegeben wird):
```
Install-Script -Name install-kubectl -Scope CurrentUser -Force
install-kubectl.ps1 [-DownloadLocation <path>]
```
{{< note >}}Wenn Sie keine `DownloadLocation` angeben, wird `kubectl` im temporären Verzeichnis des Benutzers installiert.{{< /note >}}
Das Installationsprogramm erstellt `$HOME/.kube` und weist es an, eine Konfigurationsdatei zu erstellen
2. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
{{< note >}}Die Aktualisierung der Installation erfolgt durch erneutes Ausführen der beiden in Schritt 1 aufgelisteten Befehle.{{< /note >}}
## Installation auf Windows mit Chocolatey oder scoop
Um kubectl unter Windows zu installieren, können Sie entweder den Paketmanager [Chocolatey](https://chocolatey.org) oder das Befehlszeilen-Installationsprogramm [scoop](https://scoop.sh) verwenden.
{{< tabs name="kubectl_win_install" >}}
{{% tab name="choco" %}}
choco install kubernetes-cli
{{% /tab %}}
{{% tab name="scoop" %}}
scoop install kubectl
{{% /tab %}}
{{< /tabs >}}
2. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
3. Navigieren Sie zu Ihrem Heimatverzeichnis:
```
cd %USERPROFILE%
```
4. Erstellen Sie das `.kube`-Verzeichnis:
```
mkdir .kube
```
5. Wechseln Sie in das soeben erstellte `.kube`-Verzeichnis:
```
cd .kube
```
6. Konfigurieren Sie kubectl für die Verwendung eines Remote-Kubernetes-Clusters:
```
New-Item config -type file
```
{{< note >}}Bearbeiten Sie die Konfigurationsdatei mit einem Texteditor Ihrer Wahl, z.B. Notepad.{{< /note >}}
## Download als Teil des Google Cloud SDK herunter
Sie können kubectl als Teil des Google Cloud SDK installieren.
1. Installieren Sie das [Google Cloud SDK](https://cloud.google.com/sdk/).
2. Führen Sie den `kubectl`-Installationsbefehl aus:
```
gcloud components install kubectl
```
3. Testen Sie, ob die installierte Version ausreichend aktuell ist:
```
kubectl version
```
## Installation der kubectl Anwendung mit curl
{{< tabs name="kubectl_install_curl" >}}
{{% tab name="macOS" %}}
1. Laden Sie die neueste Version herunter:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/darwin/amd64/kubectl
```
Um eine bestimmte Version herunterzuladen, ersetzen Sie den Befehlsteil `$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)` mit der jeweiligen Version.
Um beispielsweise die Version {{< param "fullversion" >}} auf macOS herunterzuladen, verwenden Sie den folgenden Befehl:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/{{< param "fullversion" >}}/bin/darwin/amd64/kubectl
```
2. Machen Sie die kubectl-Binärdatei ausführbar.
```
chmod +x ./kubectl
```
3. Verschieben Sie die Binärdatei in Ihren PATH.
```
sudo mv ./kubectl /usr/local/bin/kubectl
```
{{% /tab %}}
{{% tab name="Linux" %}}
1. Laden Sie die neueste Version mit dem Befehl herunter:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl
```
Um eine bestimmte Version herunterzuladen, ersetzen Sie den Befehlsteil `$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)` mit der jeweiligen Version.
Um beispielsweise die Version {{< param "fullversion" >}} auf Linux herunterzuladen, verwenden Sie den folgenden Befehl:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/{{< param "fullversion" >}}/bin/linux/amd64/kubectl
```
2. Machen Sie die kubectl-Binärdatei ausführbar.
```
chmod +x ./kubectl
```
3. Verschieben Sie die Binärdatei in Ihren PATH.
```
sudo mv ./kubectl /usr/local/bin/kubectl
```
{{% /tab %}}
{{% tab name="Windows" %}}
1. Laden Sie das aktuellste Release {{< param "fullversion" >}} von [disem link](https://storage.googleapis.com/kubernetes-release/release/{{< param "fullversion" >}}/bin/windows/amd64/kubectl.exe) herunter.
Oder, sofern Sie `curl` installiert haven, verwenden Sie den folgenden Befehl:
```
curl -LO https://storage.googleapis.com/kubernetes-release/release/{{< param "fullversion" >}}/bin/windows/amd64/kubectl.exe
```
Informationen zur aktuellen stabilen Version (z. B. für scripting) finden Sie unter [https://storage.googleapis.com/kubernetes-release/release/stable.txt](https://storage.googleapis.com/kubernetes-release/release/stable.txt).
2. Verschieben Sie die Binärdatei in Ihren PATH.
{{% /tab %}}
{{< /tabs >}}
## kubectl konfigurieren
Damit kubectl einen Kubernetes-Cluster finden und darauf zugreifen kann, benötigt es eine [kubeconfig Datei](/docs/tasks/access-application-cluster/configure-access-multiple-clusters/). Diese wird automatisch erstellt, wenn Sie einen Cluster mit kube-up.sh erstellen oder einen Minikube-Cluster erfolgreich implementieren. Weitere Informationen zum Erstellen von Clustern finden Sie in den [Anleitungen für die ersten Schritte](/docs/setup/). Wenn Sie Zugriff auf einen Cluster benötigen, den Sie nicht erstellt haben, lesen Sie die [Cluster-Zugriff freigeben Dokumentation](/docs/tasks/access-application-cluster/configure-access-multiple-clusters/).
Die kubectl-Konfiguration befindet sich standardmäßig unter `~/.kube/config`.
## Überprüfen der kubectl-Konfiguration
Überprüfen Sie, ob kubectl ordnungsgemäß konfiguriert ist, indem Sie den Clusterstatus abrufen:
```shell
kubectl cluster-info
```
Wenn Sie eine URL-Antwort sehen, ist kubectl korrekt für den Zugriff auf Ihren Cluster konfiguriert.
Wenn eine Meldung ähnlich der folgenden angezeigt wird, ist kubectl nicht richtig konfiguriert oder kann keine Verbindung zu einem Kubernetes-Cluster herstellen.
```shell
The connection to the server <server-name:port> was refused - did you specify the right host or port?
```
Wenn Sie beispielsweise vorhaben, einen Kubernetes-Cluster auf Ihrem Laptop (lokal) auszuführen, müssen Sie zunächst ein Tool wie minikube installieren und anschließend die oben genannten Befehle erneut ausführen.
Wenn kubectl cluster-info die URL-Antwort zurückgibt, Sie jedoch nicht auf Ihren Cluster zugreifen können, verwenden Sie Folgendes, um zu überprüfen, ob er ordnungsgemäß konfiguriert ist:
```shell
kubectl cluster-info dump
```
## Aktivieren der automatischen Autovervollständigung der Shell
kubectl bietet Autocompletion-Unterstützung für Bash und Zsh, was Ihnen viel Tipparbeit erspart!
Im Folgenden werden die Verfahren zum Einrichten der automatischen Vervollständigung für Bash (einschließlich der Unterschiede zwischen Linux und macOS) und Zsh beschrieben.
{{< tabs name="kubectl_autocompletion" >}}
{{% tab name="Bash on Linux" %}}
### Einführung
Das kubectl-Vervollständigungsskript für Bash kann mit dem Befehl `kubectl completion bash` generiert werden. Durch das Sourcing des Vervollständigungsskripts in Ihrer Shell wird die automatische Vervollständigung von kubectl ermöglicht.
Das Fertigstellungsskript benötigt jedoch [**bash-completion**](https://github.com/scop/bash-completion). Dies bedeutet, dass Sie diese Software zuerst installieren müssen (Sie können testen, ob Sie bereits bash-completion installiert haben, indem Sie `type _init_completion` ausführen).
### Installation von bash-completion
bash-completion wird von vielen Paketmanagern bereitgestellt (siehe [hier](https://github.com/scop/bash-completion#installation)). Sie können es mittels `apt-get install bash-completion` oder `yum install bash-completion`, usw.
Die obigen Befehle erstellen `/usr/share/bash-completion/bash_completion`,Dies ist das Hauptskript für die Bash-Vollendung. Abhängig von Ihrem Paketmanager müssen Sie diese Datei manuell in Ihre `~ / .bashrc`-Datei eingeben.
Um dies herauszufinden, laden Sie Ihre Shell erneut und führen Sie `type _init_completion` aus. Wenn der Befehl erfolgreich ist, ist bereits alles vorbereitet. Andernfalls fügen Sie der `~/.bashrc`-Datei Folgendes hinzu:
```shell
source /usr/share/bash-completion/bash_completion
```
Laden Sie Ihre Shell erneut und vergewissern Sie sich, dass bash-completion korrekt installiert ist, indem Sie folgendes eingeben: `type _init_completion`.
### Aktivieren der automatische Vervollständigung von kubectl
Sie müssen nun sicherstellen, dass das kubectl-Abschlussskript in allen Ihren Shell-Sitzungen verwendet wird. Es gibt zwei Möglichkeiten, dies zu tun:
- Fügen Sie das Vervollständigungsskript Ihrer `~ /.bashrc`-Datei hinzu:
```shell
echo 'source <(kubectl completion bash)' >>~/.bashrc
```
- Fügen Sie das Vervollständigungsskript zum Verzeichnis `/etc/bash_completion.d` hinzu:
```shell
kubectl completion bash >/etc/bash_completion.d/kubectl
```
{{< note >}}
bash-completion bezieht alle Verfollständigungsskripte aus `/etc/bash_completion.d`.
{{< /note >}}
Beide Ansätze sind gleichwertig. Nach dem erneuten Laden der Shell sollte kubectl autocompletion funktionieren.
{{% /tab %}}
{{% tab name="Bash auf macOS" %}}
{{< warning>}}
macOS beinhaltet standardmäßig Bash 3.2. Das kubectl-Vervollständigunsskript erfordert Bash 4.1+ und funktioniert nicht mit Bash 3.2. Um dies zu umgehen, können Sie eine neuere Version von Bash unter macOS installieren (folgen Sie den Anweisungen [hier](https://itnext.io/upgrading-bash-on-macos-7138bd1066ba)). Die folgenden Anweisungen funktionieren nur, wenn Sie Bash 4.1 oder höher verwenden.
{{< /warning >}}
### Einführung
Das kubectl-Vervollständigungsskript für Bash kann mit dem Befehl `kubectl completion bash` generiert werden. Durch das Sourcing des Vervollständigungsskripts in Ihrer Shell wird die automatische Vervollständigung von kubectl ermöglicht.
Das Fertigstellungsskript benötigt jedoch [**bash-completion**](https://github.com/scop/bash-completion). Dies bedeutet, dass Sie diese Software zuerst installieren müssen (Sie können testen, ob Sie bereits bash-completion installiert haben, indem Sie `type _init_completion` ausführen).
### Installation von bash-completion
Sie können bash-completion mit Homebrew installieren:
```shell
brew install bash-completion@2
```
{{< note >}}
`@2` steht für bash-completion 2, was vom kubectl Vervollständigungsskript benötigt wird (es funktioniert nicht mit bash-completion 1). Für bash-completion 2 ist wiederum Bash 4.1 oder höher erforderlich. Deshalb mussten Sie Bash aktualisieren.
{{< /note >}}
Wie in der Ausgabe von `brew install` (Abschnitt "Vorsichtsmaßnahmen") angegeben, fügen Sie Ihrer `~/.bashrc` oder `~/.bash_profile`-Datei die folgenden Zeilen hinzu:
```shell
export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r /usr/local/etc/profile.d/bash_completion.sh ]] && . /usr/local/etc/profile.d/bash_completion.sh
```
Laden Sie Ihre Shell erneut und vergewissern Sie sich, dass bash-completion korrekt installiert ist, indem Sie `type _init_completion` eingeben.
### Aktivieren der automatischen Vervollständigung von kubectl
Sie müssen nun sicherstellen, dass das kubectl-Abschlussskript in allen Ihren Shell-Sitzungen verwendet wird. Es gibt mehrere Möglichkeiten, dies zu tun:
- Fügen Sie das Vervollständigungsskript Ihrer `~ /.bashrc`-Datei hinzu:
```shell
echo 'source <(kubectl completion bash)' >>~/.bashrc
```
- Fügen Sie das Vervollständigungsskript zum Verzeichnis `/etc/bash_completion.d` hinzu:
```shell
kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
```
- Wenn Sie kubectl mit Homebrew installiert haben (wie [hier](#install-with-homebrew-on-macos) beschrieben), dann wurde das Vervollständigungsskript automatisch in `/usr/local/etc/bash_completion.d/kubectl` installiert. In diesem Fall müssen Sie nichts tun.
{{< note >}}
bash-completion (falls mit Homebrew installiert) bezieht alle Vervollständigungsskripte aus dem Verzeichnis, das in der Umgebungsvariablen `BASH_COMPLETION_COMPAT_DIR`festgelegt ist.
{{< /note >}}
Alle Ansätze sind gleichwertig. Nach dem erneuten Laden der Shell sollte kubectl Autovervollständigung funktionieren.
{{% /tab %}}
{{% tab name="Zsh" %}}
Das kubectl Vervollständigungsskript für Zsh kann mit dem folgenden Befehl generiert werden: `kubectl completion zsh`. Durch das Sourcing des Completion-Skripts in Ihrer Shell wird die automatische Vervollständigung von kubectl ermöglicht.
Fügen Sie Ihrer `~/.zshrc`-Datei dazu Folgendes hinzu:
```shell
source <(kubectl completion zsh)
```
Nach dem erneuten Laden der Shell sollte kubectl Autovervollständigung funktionieren.
Wenn eine Fehlermeldung wie `complete: 13: command not found: compdef` angezeigt wird, fügen Sie am Anfang der Datei `~/.zshrc" folgendes hinzu:
```shell
autoload -Uz compinit
compinit
```
{{% /tab %}}
{{< /tabs >}}
{{% /capture %}}
{{% capture whatsnext %}}
[Erfahren Sie, wie Sie Ihre Anwendung starten und verfügbar machen.](/docs/tasks/access-application-cluster/service-access-application-cluster/)
{{% /capture %}}

132
content/de/docs/tasks/tools/install-minikube.md Normal file
View File

@ -0,0 +1,132 @@
---
title: Installation von Minikube
content_template: templates/task
weight: 20
card:
name: tasks
weight: 10
---
{{% capture overview %}}
Diese Seite zeigt Ihnen, wie Sie [Minikube](/docs/tutorials/hello-minikube) installieren, ein Programm, das einen Kubernetes-Cluster mit einem einzigen Node in einer virtuellen Maschine auf Ihrem Laptop ausführt.
{{% /capture %}}
{{% capture prerequisites %}}
Die VT-x- oder AMD-v-Virtualisierung muss im BIOS Ihres Computers aktiviert sein. Um dies unter Linux zu überprüfen, führen Sie Folgendes aus und vergewissern Sie sich, dass die Ausgabe nicht leer ist:
```shell
egrep --color 'vmx|svm' /proc/cpuinfo
```
{{% /capture %}}
{{% capture steps %}}
## Einen Hypervisor installieren
Wenn noch kein Hypervisor installiert ist, installieren Sie jetzt einen für Ihr Betriebssystem:
Betriebssystem | Unterstützte Hypervisoren
:----------------|:---------------------
macOS | [VirtualBox](https://www.virtualbox.org/wiki/Downloads), [VMware Fusion](https://www.vmware.com/products/fusion), [HyperKit](https://github.com/moby/hyperkit)
Linux | [VirtualBox](https://www.virtualbox.org/wiki/Downloads), [KVM](http://www.linux-kvm.org/)
Windows | [VirtualBox](https://www.virtualbox.org/wiki/Downloads), [Hyper-V](https://msdn.microsoft.com/en-us/virtualization/hyperv_on_windows/quick_start/walkthrough_install)
{{< note >}}
Minikube unterstützt auch die Option `--vm-driver=none`, mit der die Kubernetes-Komponenten auf dem Host und nicht in einer VM ausgeführt werden. Die Verwendung dieses Treibers erfordert Docker und eine Linux-Umgebung, jedoch keinen Hypervisor.
{{< /note >}}
## Kubectl installieren
* Installieren Sie kubectl gemäß den Anweisungen in [kubectl installieren und einrichten](/docs/tasks/tools/install-kubectl/).
## Minikube installieren
### macOS
Die einfachste Möglichkeit, Minikube unter macOS zu installieren, ist die Verwendung von [Homebrew](https://brew.sh):
```shell
brew cask install minikube
```
Sie können es auch auf macOS installieren, indem Sie eine statische Binärdatei herunterladen:
```shell
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64 \
&& chmod +x minikube
```
So fügen Sie die Minikube-Programmdatei auf einfache Weise Ihrem Pfad hinzu:
```shell
sudo mv minikube /usr/local/bin
```
### Linux
{{< note >}}
Dieses Dokument zeigt Ihnen, wie Sie Minikube mit einer statischen Binärdatei unter Linux installieren. Für alternative Linux-Installationsmethoden siehe [Andere Installationsmethoden](https://github.com/kubernetes/minikube#other-ways-to-install) im offiziellen Minikube-GitHub-Repository.
{{< /note >}}
Sie können Minikube unter Linux installieren, indem Sie eine statische Binärdatei herunterladen:
```shell
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 \
&& chmod +x minikube
```
So fügen Sie die Minikube-Programmdatei auf einfache Weise Ihrem Pfad hinzu:
```shell
sudo cp minikube /usr/local/bin && rm minikube
```
### Windows
{{< note >}}
Um Minikube unter Windows auszuführen, müssen Sie zuerst [VirtualBox](https://www.virtualbox.org/) oder [Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/quick-start/enable-hyper-v) installieren. Hyper-V kann auf drei Versionen von Windows 10 ausgeführt werden: Windows 10 Enterprise, Windows 10 Professional und Windows 10 Education. Weitere Informationen zur Installation finden Sie im offiziellen [Minikube GitHub-Repository](https://github.com/kubernetes/minikube/#installation).
{{< /note >}}
Die einfachste Möglichkeit, Minikube unter Windows zu installieren, ist die Verwendung von [Chocolatey](https://chocolatey.org/) (als Administrator ausführen):
```shell
choco install minikube kubernetes-cli
```
Schließen Sie nach der Installation von Minikube die aktuelle CLI-Sitzung und starten Sie sie neu. Minikube sollte automatisch zu Ihrem Pfad hinzugefügt werden.
#### Manuelle installation unter Windows
Um Minikube manuell unter Windows zu installieren, laden Sie die Datei [`minikube-windows-amd64`](https://github.com/kubernetes/minikube/releases/latest) herunter, umbenennen Sie sie in `minikube.exe` und fügen Sie sie Ihrem Pfad zu.
#### Windows Installer
So installieren Sie Minikube manuell unter Windows mit [Windows Installer](https://docs.microsoft.com/en-us/windows/desktop/msi/windows-installer-portal), laden Sie die Datei [`minikube-installer.exe`](https://github.com/kubernetes/minikube/releases/latest) und führen Sie den Installer aus.
{{% /capture %}}
{{% capture whatsnext %}}
* [Kubernetes lokal über Minikube ausführen](/docs/setup/minikube/)
{{% /capture %}}
## Eine bestehende Installation bereinigen
Wenn Sie minikube bereits installiert haben, starten Sie die Anwendung:
```shell
minikube start
```
Und der Befehl gibt einen Fehler zurück:
```shell
machine does not exist
```
Müssen Sie die Konfigurationsdateien löschen:
```shell
rm -rf ~/.minikube
```

8
content/de/docs/templates/feature-state-beta.txt vendored Normal file
View File

@ -0,0 +1,8 @@
This feature is currently in a *beta* state, meaning:
* The version names contain beta (e.g. v2beta3).
* Code is well tested. Enabling the feature is considered safe. Enabled by default.
* Support for the overall feature will not be dropped, though details may change.
* The schema and/or semantics of objects may change in incompatible ways in a subsequent beta or stable release. When this happens, we will provide instructions for migrating to the next version. This may require deleting, editing, and re-creating API objects. The editing process may require some thought. This may require downtime for applications that rely on the feature.
* Recommended for only non-business-critical uses because of potential for incompatible changes in subsequent releases. If you have multiple clusters that can be upgraded independently, you may be able to relax this restriction.
* **Please do try our beta features and give feedback on them! After they exit beta, it may not be practical for us to make more changes.**

13
content/de/docs/templates/index.md vendored Normal file
View File

@ -0,0 +1,13 @@
---
headless: true
resources:
- src: "*alpha*"
title: "alpha"
- src: "*beta*"
title: "beta"
- src: "*deprecated*"
title: "deprecated"
- src: "*stable*"
title: "stable"
---

75
content/de/docs/tutorials/_index.md Normal file
View File

@ -0,0 +1,75 @@
---
title: Tutorials
main_menu: true
weight: 60
content_template: templates/concept
---
{{% capture overview %}}
Dieser Abschnitt der Kubernetes-Dokumentation enthält Tutorials.
Ein Tutorial zeigt, wie Sie ein Ziel erreichen, das größer ist als eine einzelne [Aufgabe](/docs/tasks/).
Ein Tutorial besteht normalerweise aus mehreren Abschnitten, die jeweils eine Abfolge von Schritten haben.
Bevor Sie die einzelnen Lernprogramme durchgehen, möchten Sie möglicherweise ein Lesezeichen zur Seite mit dem [Standardisierten Glossar](/docs/reference/glossary/) setzen um später Informationen nachzuschlagen.
{{% /capture %}}
{{% capture body %}}
## Grundlagen
* [Kubernetes Basics](/docs/tutorials/kubernetes-basics/) ist ein ausführliches interaktives Lernprogramm, das Ihnen hilft, das Kubernetes-System zu verstehen und einige grundlegende Kubernetes-Funktionen auszuprobieren.
* [Scalable Microservices mit Kubernetes (Udacity)](https://www.udacity.com/course/scalable-microservices-with-kubernetes--ud615) (Englisch)
* [Einführung in Kubernetes (edX)](https://www.edx.org/course/introduction-kubernetes-linuxfoundationx-lfs158x#) (Englisch)
* [Hello Minikube](/docs/tutorials/hello-minikube/)
## Konfiguration
* [Redis mit einer ConfigMap konfigurieren](/docs/tutorials/configuration/configure-redis-using-configmap/)
## Stateless Anwendungen
* [Freigeben einer externen IP-Adresse für den Zugriff auf eine Anwendung in einem Cluster](/docs/tutorials/stateless-application/expose-external-ip-address/)
* [Beispiel: Bereitstellung der PHP-Gästebuchanwendung mit Redis](/docs/tutorials/stateless-application/guestbook/)
## Stateful Anwendungen
* [StatefulSet Grundlagen](/docs/tutorials/stateful-application/basic-stateful-set/)
* [Beispiel: WordPress und MySQL mit persistenten Volumes](/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/)
* [Beispiel: Bereitstellen von Cassandra mit Stateful-Sets](/docs/tutorials/stateful-application/cassandra/)
* [ZooKeeper, ein verteiltes CP-System](/docs/tutorials/stateful-application/zookeeper/)
## CI/CD Pipeline
* [Einrichten einer CI/CD-Pipeline mit Kubernetes Teil 1: Übersicht](https://www.linux.com/blog/learn/chapter/Intro-to-Kubernetes/2017/5/set-cicd-pipeline-kubernetes-part-1-overview)
* [Einrichten einer CI/CD-Pipeline mit einem Jenkins-Pod in Kubernetes (Teil 2)](https://www.linux.com/blog/learn/chapter/Intro-to-Kubernetes/2017/6/set-cicd-pipeline-jenkins-pod-kubernetes-part-2)
* [Ausführen und Skalieren einer verteilten Kreuzworträtsel-App mit CI/CD auf Kubernetes (Teil 3)](https://www.linux.com/blog/learn/chapter/intro-to-kubernetes/2017/6/run-and-scale-distributed-crossword-puzzle-app-cicd-kubernetes-part-3)
* [CI/CD für eine verteilte Kreuzworträtsel-App auf Kubernetes einrichten (Teil 4)](https://www.linux.com/blog/learn/chapter/intro-to-kubernetes/2017/6/set-cicd-distributed-crossword-puzzle-app-kubernetes-part-4)
## Clusters
* [AppArmor](/docs/tutorials/clusters/apparmor/)
## Services
* [Source IP verwenden](/docs/tutorials/services/source-ip/)
{{% /capture %}}
{{% capture whatsnext %}}
Wenn Sie ein Tutorial schreiben möchten, lesen Sie
[Seitenvorlagen verwenden](/docs/home/contribute/page-templates/)
für weitere Informationen zum Typ der Tutorial-Seite und zur Tutorial-Vorlage.
{{% /capture %}}

271
content/de/docs/tutorials/hello-minikube.md Normal file
View File

@ -0,0 +1,271 @@
---
title: Hallo Minikube
content_template: templates/tutorial
weight: 5
menu:
main:
title: "Loslegen"
weight: 10
post: >
<p>Sind Sie bereit, Ihre Hände schmutzig zu machen? Erstellen Sie einen einfachen Kubernetes-Cluster, auf dem "Hallo Welt" für Node.js ausgeführt wird.</p>
card:
name: tutorials
weight: 10
---
{{% capture overview %}}
Dieses Tutorial zeigt Ihnen, wie Sie eine einfache "Hallo Welt" Node.js-Anwendung auf Kubernetes mit [Minikube](/docs/getting-started-guides/minikube) und Katacoda ausführen.
Katacoda bietet eine kostenlose Kubernetes-Umgebung im Browser.
{{< note >}}
Sie können dieses Tutorial auch verwenden, wenn Sie [Minikube lokal](/docs/tasks/tools/install-minikube/) installiert haben.
{{< /note >}}
{{% /capture %}}
{{% capture objectives %}}
* Stellen Sie eine Hallo-Welt-Anwendung für Minikube bereit.
* Führen Sie die App aus.
* Betrachten Sie die Log Dateien.
{{% /capture %}}
{{% capture prerequisites %}}
Dieses Lernprogramm enthält ein aus den folgenden Dateien erstelltes Container-Image:
{{< codenew language="js" file="minikube/server.js" >}}
{{< codenew language="conf" file="minikube/Dockerfile" >}}
Weitere Informationen zum `docker build` Befehl, lesen Sie die [Docker Dokumentation](https://docs.docker.com/engine/reference/commandline/build/).
{{% /capture %}}
{{% capture lessoncontent %}}
## Erstellen Sie einen Minikube-Cluster
1. Klicken Sie auf **Launch Terminal**.
{{< kat-button >}}
{{< note >}}Wenn Sie Minikube lokal installiert haben, führen Sie `minikube start` aus.{{< /note >}}
2. Öffnen Sie das Kubernetes-Dashboard in einem Browser:
```shell
minikube dashboard
```
3. In einer Katacoda-Umgebung: Klicken Sie oben im Terminalbereich auf das Pluszeichen und anschließend auf **Select port to view on Host 1**.
4. In einer Katacoda-Umgebung: Geben Sie `30000` ein und klicken Sie dann auf **Display Port**.
## Erstellen eines Deployments
Ein Kubernetes [*Pod*](/docs/concepts/workloads/pods/pod/) ist eine Gruppe von einem oder mehreren Containern, die zu Verwaltungs- und Netzwerkzwecken miteinander verbunden sind.
Der Pod in diesem Tutorial hat nur einen Container.
Ein Kubernetes [*Deployment*](/docs/concepts/workloads/controllers/deployment/) überprüft den Zustand Ihres Pods und startet den Container des Pods erneut, wenn er beendet wird.
Deployments sind die empfohlene Methode zum Verwalten der Erstellung und Skalierung von Pods.
1. Verwenden Sie den Befehl `kubectl create`, um ein Deployment zu erstellen, die einen Pod verwaltet.
Der Pod führt einen Container basierend auf dem bereitgestellten Docker-Image aus.
```shell
kubectl create deployment hello-node --image=gcr.io/hello-minikube-zero-install/hello-node
```
2. Anzeigen des Deployments:
```shell
kubectl get deployments
```
Ausgabe:
```shell
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hello-node 1 1 1 1 1m
```
3. Den Pod anzeigen:
```shell
kubectl get pods
```
Ausgabe:
```shell
NAME READY STATUS RESTARTS AGE
hello-node-5f76cf6ccf-br9b5 1/1 Running 0 1m
```
4. Cluster Events anzigen:
```shell
kubectl get events
```
5. Die Konfiguration von `kubectl` anzeigen:
```shell
kubectl config view
```
{{< note >}}Weitere Informationen zu `kubectl`-Befehlen finden Sie im [kubectl Überblick](/docs/user-guide/kubectl-overview/).{{< /note >}}
## Erstellen Sie einen Service
Standardmäßig ist der Pod nur über seine interne IP-Adresse im Kubernetes-Cluster erreichbar.
Um den "Hallo-Welt"-Container außerhalb des virtuellen Netzwerks von Kubernetes zugänglich zu machen, müssen Sie den Pod als Kubernetes [*Service*](/docs/concepts/services-networking/service/) verfügbar machen.
1. Stellen Sie den Pod mit dem Befehl `kubectl expose` im öffentlichen Internet bereit:
```shell
kubectl expose deployment hello-node --type=LoadBalancer --port=8080
```
Das Flag `--type = LoadBalancer` zeigt an, dass Sie Ihren Service außerhalb des Clusters verfügbar machen möchten.
2. Zeigen Sie den gerade erstellten Service an:
```shell
kubectl get services
```
Ausgabe:
```shell
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hello-node LoadBalancer 10.108.144.78 <pending> 8080:30369/TCP 21s
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 23m
```
Bei Cloud-Anbietern, die Load-Balancer unterstützen, wird eine externe IP-Adresse für den Zugriff auf den Dienst bereitgestellt.
Bei Minikube ermöglicht der Typ `LoadBalancer` den Dienst über den Befehl `minikube service` verfuügbar zu machen.
3. Führen Sie den folgenden Befehl aus:
```shell
minikube service hello-node
```
4. In einer Katacoda-Umgebung: Klicken Sie auf das Pluszeichen und dann auf **Select port to view on Host 1**.
5. In einer Katacoda-Umgebung: Geben Sie "30369" ein (siehe Port gegenüber "8080" in der service ausgabe), und klicken Sie dann auf
Daraufhin wird ein Browserfenster geöffnet, in dem Ihre App ausgeführt wird und die Meldung "Hello World" (Hallo Welt) angezeigt wird.
## Addons aktivieren
Minikube verfügt über eine Reihe von integrierten Add-Ons, die in der lokalen Kubernetes-Umgebung aktiviert, deaktiviert und geöffnet werden können.
1. Listen Sie die aktuell unterstützten Addons auf:
```shell
minikube addons list
```
Ausgabe:
```shell
addon-manager: enabled
coredns: disabled
dashboard: enabled
default-storageclass: enabled
efk: disabled
freshpod: disabled
heapster: disabled
ingress: disabled
kube-dns: enabled
metrics-server: disabled
nvidia-driver-installer: disabled
nvidia-gpu-device-plugin: disabled
registry: disabled
registry-creds: disabled
storage-provisioner: enabled
```
2. Aktivieren Sie ein Addon, zum Beispiel `heapster`:
```shell
minikube addons enable heapster
```
Ausgabe:
```shell
heapster was successfully enabled
```
3. Sehen Sie sich den Pod und den Service an, den Sie gerade erstellt haben:
```shell
kubectl get pod,svc -n kube-system
```
Ausgabe:
```shell
NAME READY STATUS RESTARTS AGE
pod/heapster-9jttx 1/1 Running 0 26s
pod/influxdb-grafana-b29w8 2/2 Running 0 26s
pod/kube-addon-manager-minikube 1/1 Running 0 34m
pod/kube-dns-6dcb57bcc8-gv7mw 3/3 Running 0 34m
pod/kubernetes-dashboard-5498ccf677-cgspw 1/1 Running 0 34m
pod/storage-provisioner 1/1 Running 0 34m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/heapster ClusterIP 10.96.241.45 <none> 80/TCP 26s
service/kube-dns ClusterIP 10.96.0.10 <none> 53/UDP,53/TCP 34m
service/kubernetes-dashboard NodePort 10.109.29.1 <none> 80:30000/TCP 34m
service/monitoring-grafana NodePort 10.99.24.54 <none> 80:30002/TCP 26s
service/monitoring-influxdb ClusterIP 10.111.169.94 <none> 8083/TCP,8086/TCP 26s
```
4. Deaktivieren Sie `heapster`:
```shell
minikube addons disable heapster
```
Ausgabe:
```shell
heapster was successfully disabled
```
## Aufräumen
Jetzt können Sie die in Ihrem Cluster erstellten Ressourcen bereinigen:
```shell
kubectl delete service hello-node
kubectl delete deployment hello-node
```
Stoppen Sie optional die virtuelle Minikube-Maschine (VM):
```shell
minikube stop
```
Löschen Sie optional die Minikube-VM:
```shell
minikube delete
```
{{% /capture %}}
{{% capture whatsnext %}}
* Lernen Sie mehr über [Bereitstellungsobjekte](/docs/concepts/workloads/controllers/deployment/).
* Lernen Sie mehr über [Anwendungen bereitstellen](/docs/user-guide/deploying-applications/).
* Lernen Sie mehr über [Serviceobjekte](/docs/concepts/services-networking/service/).
{{% /capture %}}

119
content/de/docs/tutorials/kubernetes-basics/_index.html Normal file
View File

@ -0,0 +1,119 @@
---
title: Kubernetes Grundlagen lernen
linkTitle: Kubernetes Grundlagen lernen
weight: 10
card:
name: tutorials
weight: 20
title: Schritt-für-Schritt Grundlagen
---
<!DOCTYPE html>
<html lang="de">
<body>
<div class="layout" id="top">
<main class="content">
<div class="row">
<div class="col-md-9">
<h2>Kubernetes Grundlagen</h2>
<p>Dieses Tutorial bietet einen Überblick über die Grundlagen des Kubernetes-Cluster-Orchestrierungssystems. Jedes Modul enthält einige Hintergrundinformationen zu den wichtigsten Funktionen und Konzepten von Kubernetes sowie ein interaktives Online-Lernprogramm. Mit diesen interaktiven Lernprogrammen können Sie einen einfachen Cluster und seine containerisierten Anwendungen selbst verwalten.</p>
<p>Mithilfe der interaktiven Tutorials können Sie Folgendes lernen:</p>
<ul>
<li>Eine containerisierte Anwendung in einem Cluster bereitstellen</li>
<li>Skalieren des Deployments</li>
<li>Aktualisieren der containerisierten Anwendung mit einer neuen Softwareversion</li>
<li>Debuggen der containerisierten Anwendung</li>
</ul>
<p>In den Lernprogrammen wird mit Katacoda ein virtuelles Terminal in Ihrem Webbrowser ausgeführt, in dem Minikube ausgeführt wird. Dies ist eine kleine lokale Bereitstellung von Kubernetes, die überall ausgeführt werden kann. Es muss keine Software installiert oder konfiguriert werden. Jedes interaktive Lernprogramm wird direkt von Ihrem Webbrowser aus ausgeführt.</p>
</div>
</div>
<br>
<div class="row">
<div class="col-md-9">
<h2>Was kann Kubernetes für Sie tun?</h2>
<p>Bei modernen Webservices erwarten Benutzer, dass Anwendungen rund um die Uhr verfügbar sind, und Entwickler erwarten, mehrmals täglich neue Versionen dieser Anwendungen bereitzustellen (deployen).
Containerisierung hilft bei der Paketierung von Software, um diese Ziele zu erreichen, sodass Anwendungen einfach und schnell ohne Ausfallzeiten veröffentlicht und aktualisiert werden können. Kubernetes hilft Ihnen dabei, sicherzustellen, dass diese Containeranwendungen immer dort laufen, wo und wann Sie möchten, und hilft ihnen, die Ressourcen und Tools zu finden, die sie zum Arbeiten benötigen. Kubernetes ist eine produktionsbereite Open-Source-Plattform, die auf der gesammelten Erfahrung von Google in der Container-Orchestrierung basiert und mit den besten Ideen der Community kombiniert wird.</p>
</div>
</div>
<div id="basics-modules" class="content__modules">
<h2>Kubernets Grundlagen Module</h2>
<div class="row">
<div class="col-md-12">
<div class="row">
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/create-cluster/cluster-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_01.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/create-cluster/cluster-intro/"><h5>1. Erstellen Sie einen Kubernetes-Cluster</h5></a>
</div>
</div>
</div>
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_02.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/"><h5>2. Stellen Sie eine App bereit</h5></a>
</div>
</div>
</div>
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/explore/explore-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_03.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/explore/explore-intro/"><h5>3. Erkunden Sie Ihre App</h5></a>
</div>
</div>
</div>
</div>
</div>
<div class="col-md-12">
<div class="row">
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/expose/expose-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_04.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/expose/expose-intro/"><h5>4. Machen Sie Ihre App öffentlich zugänglich</h5></a>
</div>
</div>
</div>
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/scale/scale-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_05.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/scale/scale-intro/"><h5>5. Skalieren Sie Ihre App</h5></a>
</div>
</div>
</div>
<div class="col-md-4">
<div class="thumbnail">
<a href="/docs/tutorials/kubernetes-basics/update/update-intro/"><img src="/docs/tutorials/kubernetes-basics/public/images/module_06.svg?v=1469803628347" alt=""></a>
<div class="caption">
<a href="/docs/tutorials/kubernetes-basics/update/update-intro/"><h5>6. Aktualisieren Sie Ihre App</h5></a>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/create-cluster/cluster-intro/" role="button">Starten Sie das Tutorial<span class="btn__next">›</span></a>
</div>
</div>
</main>
</div>
</body>
</html>

2
content/de/docs/tutorials/kubernetes-basics/create-cluster/_index.md
View File

@ -1,4 +1,4 @@
---
title: Erstellen Sie einen Cluster
title: Einen Cluster erstellen
weight: 10
---

2
content/de/docs/tutorials/kubernetes-basics/create-cluster/cluster-interactive.html
View File

@ -25,7 +25,7 @@ weight: 20
</div>
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/" role="button">Weiter zu Modul 2<span class="btn__next">›</span></a>
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-app/deploy-intro/" role="button">Weiter mit Modul 2<span class="btn__next">›</span></a>
</div>
</div>

4
content/de/docs/tutorials/kubernetes-basics/deploy-app/_index.md Normal file
View File

@ -0,0 +1,4 @@
---
title: Eine App bereitstellen
weight: 20
---

41
content/de/docs/tutorials/kubernetes-basics/deploy-app/deploy-interactive.html Normal file
View File

@ -0,0 +1,41 @@
---
title: Interaktives Lernprogramm - Bereitstellen einer App
weight: 20
---
<!DOCTYPE html>
<html lang="en">
<body>
<link href="/docs/tutorials/kubernetes-basics/public/css/styles.css" rel="stylesheet">
<link href="/docs/tutorials/kubernetes-basics/public/css/overrides.css" rel="stylesheet">
<script src="https://katacoda.com/embed.js"></script>
<div class="layout" id="top">
<main class="content katacoda-content">
<br>
<div class="katacoda">
<div class="katacoda__alert">
Um mit dem Terminal zu interagieren, verwenden Sie bitte die Desktop- / Tablet-Version
</div>
<div class="katacoda__box" id="inline-terminal-1" data-katacoda-id="kubernetes-bootcamp/7" data-katacoda-color="326de6" data-katacoda-secondary="273d6d" data-katacoda-hideintro="false" data-katacoda-font="Roboto" data-katacoda-fontheader="Roboto Slab" data-katacoda-prompt="Kubernetes Bootcamp Terminal" style="height: 600px;">
</div>
</div>
<div class="row">
<div class="col-md-12">
<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/explore/explore-intro/" role="button">Weiter mit Modul 3<span class="btn__next">›</span></a>
</div>
</div>
</main>
</div>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More