Mis järgmiseks

• Lugege lisateavet kaustade ja konteinerite konfigureerimise kohta.
• Lisateave konteineris käskude käitamise kohta.
• Vt konteiner.

Viimati muudetud 9. septembril 2022 kell 22:54 PST: parandage paigutust (f6fa07357d)

Kubectl Execi kasutamine

kubectl exectäidab käsu töötavas konteineris. Sellel on järgmine põhisüntaks:

$ kubectl exec demo-pod -- demo-käsk

See töötab Podi demo-commandesimese konteineri sees . demo-podKäsk täidetakse juurõigustega. Interaktiivse terminaliseansi seadistamiseks on vaja täiendavaid lippe:

• --stdin( -i) – sisestage oma terminali standardne sisendvoog konteinerisse.
• --tty( -t) – Märkige standardne sisendvoog TTY-ks, muutes selle interaktiivseks.

Siin on näide kesta hankimisest Podi esimesse konteinerisse:

$ kubectl exec -it demo-pod -- /bin/sh

Kõik pärast seda --muutub konteineris täidetava käsu osaks. kubectl execignoreerib konteineri vaikesisendepunkti, käivitades selle asemel uue protsessi teie määratud käsuga. Ärge mähkige käsku jutumärkidesse ( "/bin/sh"), välja arvatud juhul, kui kasutaksite neid käsu lokaalsel käivitamisel tavapäraselt.

Erineva konteineri valimine

kubectl execloob ühenduse Podi vaikekonteineriga, kui muid argumente pole antud. Vaikekonteiner on see, millel on kubectl.kubernetes.io/default-containermärkus. See on Podi esimene konteiner, kui te pole ühelegi teisele märkust käsitsi lisanud. Siin on Pod, millel on kaks konteinerit:

apiVersion : v1  tüüp : Podi  metaandmed :  nimi : demo- podi  spetsifikatsioon :  konteinerid :  - nimi : rakenduse konteineri  pilt : nginx: uusim  - nimi : külgkorvi konteineri  pilt : busybox: uusim

Saate käivitada käsu sees sidecar-container, lisades -clipu kubectl exec:

$ kubectl exec --it demo-pod -c sidecar-container -- /bin/sh

Ootan, kuni Pods hakkab tööle

Kubectl ootab minuti, kuni Pod on valmis, Runningkui selle konteinerid pole execkäsu käivitamisel veel käivitunud. Seda ajalõpu väärtust saab muuta --pod-running-timeoutlipuga. See on kasulik, kui soovite käivitada käsu kohe pärast uue Podi loomist, kui see ei pruugi olla sõlme ajastatud.

$ kubectl exec --pod-running-timeout=5m demo-pod -- demo-käsk

Millal ma peaksin seda kasutama?

kubectl execon kõige parem reserveeritud eriolukordadeks, kus peate otse konteineri failisüsteemiga suhtlema. Saate seda kasutada logidele või vahemäludele juurdepääsuks pärast probleemi või harva kasutatava majapidamisskripti käitamiseks, mis sisaldub konteineri kujutises. Kuigi kubectl execsee võimaldab teil käivitada mis tahes käsku, peaksite vältima konteineri keskkonna dramaatilist muutmist. See võib põhjustada konteineri eeldatavast olekust eemaldumise. Konteinerid ei tohiks tavaliselt sekkumist vajada, nii et kubectl execsisemiste tootmiskeskkondade kasutamine annab tavaliselt märku, et midagi on valesti läinud. Ärge kasutage seda käsku pakettide installimiseks ega värskenduste rakendamiseks konteineris. Seda tüüpi toimingute tegemiseks tuleks luua uus konteineri kujutis, mis sisaldab muudatusi, ja seejärel asendada oma Kubernetes Pods nendega, mis käitavad muudetud järgu. Selle põhimõtte järgimine tagab, et teie muudatused ei läheks kaduma, kui Pod taaskäivitub ja naaseb konteineri kujutise failisüsteemi. Konteinerite muutumatuna hoidmine tagab ka nende kujutiste usaldusväärse reprodutseerimise, mis suurendab töökindlust ja silumise lihtsust.

Kokkuvõte

Ühekordse käsu käivitamine Kubernetese konteineris võimaldab teil probleeme siluda, teha hooldustoiminguid ja kontrollida konteineri failisüsteemi. Kõigis neis olukordades saate kubectl execkonteineriga ühenduse loomiseks kasutada. Lipukombinatsiooni lisamine -itedastab teie terminali standardse sisendvoo TTY-na, pakkudes interaktiivset shelliseanssi. See ei ole alati vajalik olenevalt kasutatavast käsust: kui see annab ainult väljundi, ilma sisendit nõudmata, võite lipud ohutult välja jätta. LUGEGE EDASI

• › Kuidas kasutada oma autot elektrikatkestuse ajal hädaolukorras elektriallikana
• › Kuidas Facebooki blokeeringut tühistada
• › StumbleUpon muutis Interneti väikeseks
• › Autoriõiguse sümboli lisamine dokumendile Windowsis ja Macis
• › Kuidas Apple’i kella sihverplaate automaatselt vahetada
• › Kui palju raha säästab LED-jõulutuledele üleminek?

How-To Geek on koht, kuhu pöörduda, kui soovite, et eksperdid tehnoloogiat selgitaksid. Alates käivitamisest 2006. aastal on meie artikleid loetud rohkem kui 1 miljard korda. Kas soovite rohkem teada? Tere, lugejad! See artikkel räägib käskude ja argumentide kasutamisest Kubernetes Podis erinevate stsenaariumitega, et paremini mõista. Niisiis, alustame!!

Käskude ja argumentide kasutamine – protsessi täitmine

Kui me ütleme, et rakendus töötab Kubernetes Podis, peame tegelikult silmas seda, et konteiner on pakitud ja esitatud Podina. Konteiner koondab kõik protsesside koos käivitamiseks vajalikud sõltuvused ja käsud ning asub Podis. Podi loomise ajal saame määratleda käsud ja argumendid, mis konteineris üldse töötavad. Tavaliselt alistavad kohandatud vormis määratletud käsk ja argumendid põhikonteineri kujutise vaikekäsu ja argumendid. Selle teema kontekstis käsitleme võimalusi, kuidas luua ja määratleda käske ja argumente konteinerina, mis töötab rakenduse Pod-na.

Määratlege Kubernetes Podi käsud ja argumendid

Argumendi määratlemiseks konteineris saame kasutada käsuvälja . Hetkel, kui me käske määratleme, vajaksime sellele edastamiseks argumente. Saame need argumendid käsule edastada välja args abil. Allolevas näites oleme andnud konteinerile käsu printenv , et see printiks keskkonnamuutuja KUBECONFIG väärtused sellele argumendina. Näide: pod.YAML

apiVersion: v1 kind: Pod metadata: name: demo-cmd spec: containers: - name: cmd-arg-demo image: debian command: ["printenv"] args: ["KUBECONFIG"] restartPolicy: OnFailure 

Rakendame nüüd ülaltoodud faili ja loome Pod.

kubectl apply -f pod.yaml 

Kui oleme Podi loonud, saame käskluse ja konkreetse konteineri logid, et otsida käsu täitmise tulemust.

kubectl logs -f demo-cmd 

Väljund: Väljund tagastab käsu täitmise väärtuse. See tähendab, et see kuvab väärtusena KUBECONFIG-faili tee.

/home/.kube 

1. Env muutujate kasutamine argumentide määratlemiseks

Ühe variandina saame argumentide väärtuste käskudele edastamiseks kasutada keskkonnamuutujaid. Vaatame allolevat koodiosa Näide: näidiskood

env: - name: data value: "002234-welcome-message" command: ["/bin/data"] args: ["$(data)"] 

Kasutades ülaltoodud koodiplokki, saame argumentide väärtused edastada keskkonnamuutuja abil. Siin edastame argumendi väärtuse käsule muutuja nimega andmed , mille väärtus on määratud keskkonnamuutujana. Lisaks keskkonnamuutujatele saame sarnasel viisil sõeluda ka väärtuse ConfigMap ja Secret kujul.

2. Käskude käivitamine kestas

Mõnikord, kui soovime täita mitut käsku, vajame täitmiseks kesta, mis töötaks konteineris. Seda on võimalik saavutada virtuaalse kesta käivitamisega tööajal. Sama jaoks määratleme käsu kõigi määratud käskude käivitamiseks kestas olevas Podis, nagu allpool näidatud –

command: ["/bin/sh"] args: ["-c", "while true; do echo Welcome to JournalDev; sleep 100;done"] 

Siin, selles näites, oleme andnud Podile korralduse kasutada kesta, et käivitada BASH-skript, mis täidab kokku mitu käsku, näiteks while-tsükli täitmine.

Järeldus

Sellega oleme jõudnud selle teema lõpuni. Kui teil tekib küsimusi, kommenteerige julgelt allpool. Dockeri ja Kubernetese kohta lisateabe saamiseks hoidke meiega kursis. Seniks head õppimist! Konteinereid kasutatakse tarkvara ja kõigi selle sõltuvuste pakendamiseks enne juurutamist. Enne konteinerite ajastut pidid tarkvaraarendajad juurutamise ajal tegelema ühilduvusprobleemidega. Need võivad ilmneda siis, kui tarkvara töötab arendusfaasis korralikult, kuid ei tööta tootmiskeskkonna sõltuvusprobleemide tõttu. Konteinerite puhul saab aga kõik arenduseks kasutatavad tarkvarasõltuvused tarnida ja tootmiskeskkonnas kasutada. Pärast konteineri kujutise loomist ja selle eksemplari käitamist peate võib-olla avama konteineri silumiseks või proovima kiirparandust, mis nõuab juurdepääsu konteinerikeskkonnale. Mis tahes töötava konteineriga suhtlemiseks peate mis tahes ülesande täitmiseks sisenema selle kesta. See artikkel näitab teile, kuidas saada kest töötavasse Dockeri konteinerisse või Kubernetese kausta. See aitab teil mõista ka selle tegemise tähtsust ja seda, kuidas oma ülesande täitmiseks lippe kasutada.

Põhjused, miks sattuda töötavasse konteinerikarpi

Siin on mõned tähelepanuväärsed põhjused, miks peate võib-olla kasutama töötavat konteineri kesta.

• Arenduses olevate rakenduste silumine: kui ilmnevad vead rakenduse käitamisel töötavas konteineris, saate rakenduse konteineri kujutise taastamise ja ümberpaigutamise asemel kasutada rakenduse silumiseks konteineri kesta.
• Rakenduse konteineris käskude käitamiseks: teie rakendus võib olla programmeeritud faile serverist alla laadima. Allalaaditud failide pikkuse kinnitamiseks peate võib-olla käivitama wc -l filenamekäsu, mida kasutatakse mis tahes faili ridade arvu hankimiseks. Käsku wc -lsaab käivitada ainult konteineri kestas.
• Töötava konteineri sisemise oleku uurimine: teie töötav konteiner võib olla katki mõne tööprotsessi tõttu, mis võtavad liiga palju töötlemisvõimsust. Konteineris töötavate rakenduste kontrollimiseks peate kasutama ps auxkäsku, mis tuleb käivitada konteineri kestas.

Töötavasse Dockeri konteinerkesta sisenemine

Docker aitab arendajatel oma rakendusi koos kõigi sõltuvustega konteinerisse paigutada. Selle konteinereid kasutatakse laialdaselt kohalikuks juurutamiseks ja tootmiseks. Selle juhendi jaoks käivitate Dockeri konteineri, millel on lihtne Pythoni rakendus. Kui teil pole Dockerit veel installitud, järgige neid õpetusi, et õppida, kuidas seda Linuxi, macOS-i ja Windowsi installida.

Näidis GitHubi rakenduste hoidla kloonimine

Konteineris töötav näidisrakendus ehitati lihtsa veebiarendusraamistikuga Flask. Rakendusel on kaks lõpp-punkti: GET-lõpp-punkt, mis tagastab tervituse, ja GET-otspunkt, mis laadib alla CSV-näidisfaili ja salvestab selle. Selle juhendi jaoks peate rakenduse selle GitHubi hoidla Dockerfile’iga kloonima. Hoidla kloonimiseks käivitage allolev käsk:

 git clone https://github.com/gravitational/devrel_container_guide.git 

Järgmisena muutke oma kataloog kloonitud kaustaks ja tippige lsselle sisu kontrollimiseks.

Dockeri konteineri kujutise loomine ja konteineri käitamine

Järgmine samm on rakenduse jaoks Dockeri kujutise loomine. Käivitage kloonitud rakenduse ja Dockerfile’iga samas kataloogis docker buildkäsk:

# -t is to tag, . is to specify the current directory docker build -t demo-image . 

Dockeri konteineri kujutise käivitamiseks kasutage allolevat käsku:

docker run demo-image 

Peaksite oma terminalis nägema midagi sarnast järgmisega: Külastage terminalis kuvatavat URL-i, et näha Flaski tervituslehte koos hello worldväljundiga, mis näitab, et konteineris olev rakendus töötab. Teise lõpp-punkti testimiseks lisage /downloadURL-ile, st http://172.17.0.2:5000/download . Kuigi näete veebilehte, mis ütleb teile, et faili allalaadimine on lõppenud, kontrollime, kas fail on tegelikult alla laaditud. Kui vaatate all demo.pyolevat näidiskoodi, siis downloadlõpp-punkti tabamisel käivitatav käsk on: wget https://gist.githubusercontent.com/benarent/524f1745e49c0b416e4487bb85063fec/raw/80a537d4d1efdcef31443801aacc891a446f2bdd/SampleCSVFile_119kb.csv -O sample.csv. Kui vaatate oma terminali lähemalt, leiate tõrketeate 404, mis ütleb, et wgetkäsku ei leitud. See tähendab, et on võimalik, et wgetkäsku ei installitud Dockeri konteinerisse. Täiuslik, võimalus testida meie konteinerite silumise oskusi! Läheme konteinerikeskkonda, et kinnitada oma hüpoteesi wget.

Dockeri konteinerisse sattumine

Interaktiivsesse Dockeri konteineri keskkonda sisenemiseks, et kontrollida, kas wgetkäsk on sinna installitud, kasutage käsku vormingus

docker exec -it container_name|container_id shellname 

The exec command, with -t flag is used to allocate a pseudo-TTY connected to the standard container input, and the -i flag is used to create an interactive shell in the container. The -t flag binds an interactive terminal to the standard input of the Docker container, giving you a terminal for typing input commands that are routed to the standard input of the container by the -i flag. On Linux, TTY helps users interact with the system through the terminal. The terminal on Linux interacts with a virtual TTY, also known as a pseudo-TTY. With docker exec -it container_name|container_id bash, Docker will execute a command that binds an interactive bash terminal to your Docker container. In order to get the id of the container running our demo image simply open a new terminal and run docker ps -a. This should show you a list of all the currently running containers. Look for our container named demo-image. Once you have the container id, type docker exec -it your_container_id bash. After executing the command, you will see something similar to the following, indicating that you are inside the container’s working directory (app): Now that you are inside the container shell, you can install the wget command with apt update && apt install wget. Then, exit the container shell by typing exit. Once again, using your web browser visit the download endpoint at http://172.17.0.2:5000/download. You will see an output similar to the following, which confirms that the file was downloaded: You might now want to check the file’s length. To do so, you will need to move back into the shell of the container using the previous command, docker exec -it your_container_id bash. When inside the Docker container, type ls to check the files in the working directory. You will notice that there is now a sample.csv file, which is the file that was downloaded. To check the length of the file, run cat sample.csv. You’ll see that the file has ten lines.

Getting a shell into a Kubernetes pod

Kubernetes is a container orchestration platform for managing containers automatically. Kubernetes works with pods, which can be likened to houses with containers running inside them. To get into a shell of a pod running on Kubernetes, you’ll first deploy the previously built demo-image container image on Kubernetes and then move into a shell of the pod running a container.

Deploying a container image on Kubernetes

To deploy your previously built Docker image on Kubernetes, you need to have minikube and kubectl installed. Then, you need to define a deployment template to specify details about the container. The content below is a template for creating the demo-image pod. Save it in a file with the name demopod.yaml:

apiVersion: v1 kind: Pod metadata: name: demoapp labels: name: demoapp spec: containers: - name: demoimage image: idowuilekura/teleport_demo resources: limits: memory: "128Mi" cpu: "500m" ports: - containerPort: 5000 

Create the pod by running this command in the same directory:

kubectl create -f demopod.yaml 

To get the status of the pod, run the kubectl get pods command. You should see the something like this in your terminal, showing that the pod is running:

NAME READY STATUS RESTARTS AGE demoapp 1/1 Running 0 42s 

Getting into a shell of a container running inside a pod

You now have a new container running inside the Kubernetes pod. However, since Kubernetes deployed a new container, the changes made to the Docker container in the previous steps aren’t available again. You will need to install the wget command inside the new container image. To get into a shell of a container running on Kubernetes, you will use the command kubectl exec -it nameofpod terminal_name. It is similar to the command that you ran for Docker containers. You can also use kubectl exec --stdin --tty nameofpod -- name_of_terminal, which will bind a pseudo-TTY and route any command in the terminal to the standard input of the container. Next, run the command kubectl exec --stdin --tty demoapp -- bash to move into the container image. You can use the ls command to check the contents of the files in your Docker container, which will show the demo.py file. Install the wget command with apt update && apt install wget. You can also explore the container environment further if you wish to.

Securing your Kubernetes containers against unwanted access

Moving into the shell of a container on Kubernetes is useful for debugging and other activities, but you don’t want everyone to have access to a container shell. It can lead to disastrous results, such as your application being stopped and tampered with. Setting up role-based access in your environment is a good way to disable this functionality. Role-based access control (RBAC) can help limit how external users interact with your containers. To learn more about RBAC and how to implement it, you can check out this tutorial.

Monitoring access to Kubernetes shells with Teleport

It’s good practice to monitor access to your container shell and the activities users are performing. Teleport is one of the tools that can help you do so. It is an identity-aware, multiprotocol access proxy for accessing Kubernetes clusters easily and securely. Teleport consolidates connectivity, authentication, authorization, and auditing of Kubernetes clusters into a single platform, which helps to improve security and agility. Teleport issues users with short-lived kubeconfigs and certificates using single sign-on (SSO), and switches between clusters without logging in twice. Admins can use roles to implement policies, and organizations can achieve compliance by capturing kubectl activities. If you are interested in learning about using Teleport for Kubernetes access, you can check out this tutorial from Teleport.

Conclusion

This article showed the importance of getting into the shell of a running Docker container or Kubernetes pod and how to do it. It also touched on the importance of restricting access with RBAC in Kubernetes and how to know who is accessing your cluster with Teleport. Teleport offers an improved and streamlined Kubernetes experience for securely accessing Kubernetes clusters remotely and getting into the shells of containers and pods. It lets you easily view the status of your Kubernetes cluster. To learn more about Teleport for Kubernetes access, check out this resource.

• kubernetes

Kubernetes is a container orchestrator that lets you automate deployments across multiple physical machines. Starting a shell session to a container in a Kubernetes cluster isn’t the same as using Secure Shell (SSH) on a physical server. Although containers should be stateless and capable of running without intervention, sometimes you may need a shell to debug issues or extract data. <terminal inline>kubectl exec<terminal inline> lets you connect to containers inside your cluster. It’s part of the full kubectl CLI utility for interacting with Kubernetes installations. The <terminal inline>exec<terminal inline> command streams a shell session into your terminal, similar to <terminal inline>ssh<terminal inline> or <terminal inline>docker exec<terminal inline>. Here’s the simplest invocation to get a shell to the <terminal inline>demo-pod<terminal inline> pod:

 kubectl exec -it demo-pod -- /bin/sh 

kubectl will connect to your cluster, run <terminal inline>/bin/sh<terminal inline> inside the first container within the <terminal inline>demo-pod<terminal inline> pod, and forward your terminal’s input and output streams to the container’s process. In this article, you will examine the scenarios where <terminal inline>kubectl exec<terminal inline> is useful, what each section of the command does, and how you can customize the shell connection.

When to Use kubectl exec

Managing containerized workloads in a Kubernetes cluster requires different processes than those used for applications on a traditional bare-metal server. Because you must drill down from the cluster host to the container instances that deploy your system, there is an extra layer between you and your software. Kubernetes’s strength is its ability to distribute replicas across physical machines (nodes). Even if you could use SSH for management, you’d have to keep track of which node was running each container. <terminal inline>kubectl exec<terminal inline> lets you specify the container to connect to without worrying about the Kubernetes node it’s on. Starting a shell inside a container is most commonly used when you’re debugging a problem. After exhausting other avenues of inquiry, such as the logs produced by a container, you may have no other option than to inspect it from the inside. By running the shell commands, you can see the container’s entire file system and check if the environment is as you expected. It can also help you identify whether a critical file is missing or locked, or find instances of misconfigured environment variables.

Actions to Avoid When Using kubectl exec

Since <terminal inline>kubectl exec<terminal inline> gives you full shell access, there’s nothing to stop you from modifying the container, too. This allows you to add extra software packages to aid in your debugging. The extra software packages are sometimes necessary when you are connected to a container that uses a minimal base image where common tools may be missing. Nonetheless, you should refrain from substantially altering the container’s environment. Don’t update existing software packages or use <terminal inline>kubectl exec<terminal inline> as a way to replace your application’s source code. These operations would depart from the model of immutability and reproducibility that’s the foundation of the container movement. Instead, you should rebuild your container image then deploy the new version into your Kubernetes cluster. To summarize, <terminal inline>kubectl exec<terminal inline> is a helpful tool when you want to inspect the state of a container in your cluster. It shouldn’t generally be used to alter the state, except in specific cases where you’re adding extra debugging packages or fixing a one-off problem in the environment.

kubectl exec Syntax

Unlike a simple <terminal inline>ssh [email protected]<terminal inline> command, kubectl exec requires a few extra arguments to set up an interactive shell session. Let’s break down the command shown above:

 kubectl exec -it demo-pod -- /bin/sh 

See määrab, et soovite käivitada käsku <terminal inline>/bin/sh<terminal inline> esimeses konteineris oma <terminal inline>demo-pod<terminal inline> pod. <terminal inline>—<terminal inline> eraldab käivitatava käsu <terminal inline>kubectl<terminal inline> argumentidest. Kõik pärast <terminal inline>—<terminal inline> edastatakse konteinerisse, mitte <terminal inline>kubectl<terminal inline>. <terminal inline>-it<terminal inline> on samaväärne <terminal inline>-stdin<terminal inline> (<terminal inline>-i<terminal inline>) ja <terminal inline>-tty<terminal inline> ( <terminal inline>-t<terminal inline>) lipud. Need annavad kubectlile käsu suunata teie terminali sisendvoog <terminal inline>stdin<terminal inline> konteinerisse (<terminal inline> -i<terminal inline>) ja käsitleda seda TTY-na (<terminal inline> -t<terminal inline> ). See loob interaktiivse seansi, kus saate anda sisendi konteineris toimuvale protsessile. Ilma nende lippudeta näete kirjutuskaitstud väljundvoogu. Kui SSH käivitab automaatselt shell-protsessi ja seob teie terminali sisend- ja väljundvood, siis kubectl muudab kõik need aspektid kohandatavaks. Sa ei pea alustama kesta konteineris; Selle asemel võite käivitada suvalise protsessi, anda sellele interaktiivse sisendi ja saada selle väljundi:

 kubectl exec -it demo-pod -- node my-script.js 

Klastrite ühendused

Nagu kõik teised kubectli käsud, töötab ka <terminal inline>exec<terminal inline> klastriühendusega, mille on määratlenud teie keskkonnamuutuja <terminal inline>KUBECONFIG<terminal inline>. See peaks viitama kubeconfigi failile, mis sisaldab teie klastri ühenduse üksikasju.

 export KUBECONFIG=.kube/demo-cluster.yaml kubectl exec -it demo-pod -- /bin/sh 

Määratud konteineri nimi peab eksisteerima klastri vaikenimeruumis. Kasutage globaalset lippu <terminal inline>—namespace<terminal inline>, et seda muuta, kui viitate konteinerile teises nimeruumis:

 kubectl exec --namespace demo-namespace -it demo-pod -- /bin/sh 

Kaunad ja konteinerid

Kubernetese klastri konteinerid asuvad Podsis. Kuna iga Pod võib sisaldada mitut konteinerit, toetab <terminal inline>kubectl exec<terminal inline> täiendavat argumenti, mis võimaldab teil määrata Podi ja konteineri, millega ühenduse luua:

 kubectl exec -it demo-pod -c demo-container -- /bin/sh 

Selles näites oleks teie ühendus konteineris <terminal inline>demo-konteiner<terminal inline> konteineriga <terminal inline>demo-pod<terminal inline>. Eelmistes sammudes jätsime konteineri nime välja ja märkisime ainult kausta. Sel juhul loob kubectl automaatselt ühenduse annotatsiooniga <terminal inline>kubectl.kubernetes.io/default-container<terminal inline> või esimese konteineriga Podis, kui märkusi ei kasutata. Samuti saate otse viidata kõrgema taseme ressursile, näiteks juurutusele. See viide võimaldab teil kiiresti ühenduse luua konteineriga, ilma et peaksite teadma selle täpset nime:

 kubectl exec -it deployment/demo-deployment -- /bin/sh 

Ülaltoodud käsk annaks teile shellisessiooni esimesele konteinerile juurutuse <terminal inline>demo-deployment<terminal inline> raames. See eemaldab vajaduse käivitada <terminal inline>kubectl get pods<terminal inline>, et leida Podi nimed enne <terminal inline>exec<terminal inline> kasutamist.

Täpsemad valikud

<terminal inline>kubectl exec<terminal inline> toetab paari lisavalikut, mis võimaldavad teil selle toimimist kohandada:

• <terminal inline> — vaikne<terminal inline> (<terminal inline> -q<terminal inline>) : see keelab kogu kubectli enda väljundi. Näete ainult konteineris töötava protsessi väljundit.
• <terminal inline>—pod-running-timeout<terminal inline> : see võimaldab teil kohandada ajalõpu, enne kui kubectl loobub ühenduse loomisest, kui ühtegi sobivat Pod ei tööta. Vaikeväärtus <terminal inline>1m0s<terminal inline> tähendab, et kubectl ootab kuni minuti, kuni Pod on saadaval.

Need argumendid tuleks edastada käsu kubectl osale enne eraldajat —, mis alustab konteinerisisektsiooni.

Kubectl exec alternatiivid

<terminal inline>kubectl exec<terminal inline> on parim valik kesta hankimiseks Kubernetese konteinerisse. See on loodud spetsiaalselt selleks otstarbeks ja väldib kõiki probleeme, mis on seotud õige füüsilise sõlme tuvastamisega, millega ühenduse luua. Kui vajate tõesti alternatiivi, võib-olla seetõttu, et peate ühenduse looma ilma kubectlita süsteemist, võiksite kaaluda SSH-deemoni käivitamist konteineris. Olge ettevaatlik, et see suurendab teie turvarünnakute pinda ja on vastuolus ideega, et igal konteineril on üksainus eesmärk. Teine võimalus on veebipõhise Kubernetese armatuurlaua seadistamine. Paljud populaarsed valikud, sealhulgas ametlik armatuurlaud, võimaldavad teie brauseris interaktiivseid shelliseansse.

Viimased mõtted

Käsk <terminal inline>kubectl exec<terminal inline> võimaldab teil alustada shellisessiooni teie Kubernetese klastris töötavates konteinerites. See käsk võimaldab teil kontrollida konteineri failisüsteemi, kontrollida keskkonna olekut ja kasutada täpsemaid silumistööriistu, kui logid üksi ei anna piisavalt teavet. Shellikäskude käsitsi kasutamine peaks olema teie konteinerite haldamise viimane abinõu. Kubernetese mõõdikute ja kriitiliste sündmuste igapäevast jälgimist teenindavad paremini spetsiaalsed platvormid, nagu ContainIQ, mis võimaldab teil klastri tervise jälgimiseks kasutada eelehitatud armatuurlaudu.

• Kuidas rar-faile esitada
• Kuidas valmistada sinepirohelist
• Kuidas tulla toime oma isa surmaga (noortele)
• Kuidas vabastada aeglaselt töötav vannitoa valamu äravool
• Kuidas lisada telefonile juhtmevaba laadimist, kui see seda ei toeta