diff --git a/.github/workflows/pandoc.yml b/.github/workflows/pandoc.yml new file mode 100644 index 0000000..43466aa --- /dev/null +++ b/.github/workflows/pandoc.yml @@ -0,0 +1,25 @@ +name: Pandoc eBook Generation +on: + workflow_run: + workflows: ["Ibis eBook Generation"] + types: + - completed + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@main + with: + fetch-depth: "0" + - name: Build Pandoc Export Files + uses: mph7/pandoc-build-action@main + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + PANDOC_PATH: "./ebook/en/content/" + YML_PATH: "./ebook/en/epub.yml" + EXPORT_PATH: "./ebook/en/export/" + EXPORTED_FILE: "introduction-to-bash-scripting.epub" + PANDOC_BRANCH: "main" + EMAIL: "bobby@bobbyiliev.com" + COMMIT_MESSAGE: "Updated Pandoc Exported Files" diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 64ce3eb..23f5295 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -25,7 +25,7 @@ If you are adding a new translation, make sure to make a copy of the `./ebook/en All the Markdown files for the 'Introduction to Bash Scripting' guide are located within the [`content`](./content) directory for the specific language. -For example if you are adding a Bulgarian transaltion copy the `./ebook/en` folder to `./ebook/bg`, translate the `.md` files in the `content` directory and submit a PR. +For example if you are adding a Bulgarian translation copy the `./ebook/en` folder to `./ebook/bg`, translate the `.md` files in the `content` directory and submit a PR. ### PDF Generation @@ -37,7 +37,7 @@ Make sure to follow the steps on how to get Ibis installed and how to use it her ## Issue Creation -In the event that you have a issue using the guide or have a suggest for a change but don't want to contribute changes, +In the event that you have an issue using the guide or have a suggestion for a change but don't want to contribute changes, we are more than happy to help. Make sure that when you create your issue, it follows the format for the type of issue you select (it has individual templates for each issue type). diff --git a/README.md b/README.md index 1e1b472..4ab87ca 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,8 @@ To download a copy of the ebook use one of the following links: * [Light mode](https://github.com/bobbyiliev/introduction-to-bash-scripting/raw/main/ebook/en/export/introduction-to-bash-scripting-light.pdf) +* [ePub](https://github.com/bobbyiliev/introduction-to-bash-scripting/raw/main/ebook/en/export/introduction-to-bash-scripting.epub) + ## 📘 Chapters The first 13 chapters would be purely focused on getting some solid Bash scripting foundations then the rest of the chapters would give you some real life examples and scripts. @@ -58,6 +60,12 @@ The first 13 chapters would be purely focused on getting some solid Bash scripti This book is made possible thanks to these fantastic companies! +### 📊 Materialize + +The Streaming Database for Real-time Analytics. + +[Materialize](https://materialize.com/) is a reactive database that delivers incremental view updates. Materialize helps developers easily build with streaming data using standard SQL. + ### 💙 DigitalOcean DigitalOcean is a cloud services platform delivering the simplicity developers love and businesses trust to run production applications at scale. @@ -104,18 +112,6 @@ If you prefer watching videos rather than reading, you can find a quick crash co **[Introduction to Bash Scripting Mini Video Crash Course](https://www.youtube.com/playlist?list=PLY7SzAmnEqp78tsHh1kK0gOx_f-uwQZAT)** -## 💻 Interactive training - -You can follow the interactive training online here: - -[Introduction to Bash Scripting Interactive training](https://ebook.bobby.sh/training.html) - -The training was built with Katacoda. You can find the Katacoda repository [here](https://github.com/bobbyiliev/katacoda). - -For more information on how to use Katacoda make sure to follow the steps from this tutorial here: - -[How to Use Katacoda to Create Highly Engaging Training Tutorials](https://devdojo.com/bobbyiliev/how-to-use-katacoda-to-create-highly-engaging-training-tutorials) - ## 👋 About the author My name is Bobby Iliev, and I have been working as a Linux DevOps Engineer since 2014. I am an avid Linux lover and supporter of the open-source movement philosophy. I am always doing that which I cannot do in order that I may learn how to do it, and I believe in sharing knowledge. @@ -124,7 +120,7 @@ I think it's essential always to keep professional and surround yourself with go For more information, please visit my blog at [https://bobbyiliev.com](https://bobbyiliev.com), follow me on Twitter [@bobbyiliev_](https://twitter.com/bobbyiliev_) and [YouTube](https://www.youtube.com/channel/UCQWmdHTeAO0UvaNqve9udRw). -In case that you want to support me you can By Me a Coffee here: +In case that you want to support me you can Buy Me a Coffee here: Buy Me A Coffee @@ -148,16 +144,16 @@ If you ever need to create a graphic, poster, invitation, logo, presentation – - [Ibis](https://github.com/themsaid/ibis/) - [Canva](https://www.canva.com/) - [Tails](http://devdojo.com/tails) -- [Katacoda](https://www.katacoda.com/) ## 📖 Other eBooks -- [Introduction to Git and GitHub eBook](https://github.com/bobbyiliev/introduction-to-git-and-github-ebook) +- [Introduction to Docker](https://github.com/bobbyiliev/introduction-to-docker-ebook) +- [Introduction to Git and GitHub](https://github.com/bobbyiliev/introduction-to-git-and-github-ebook) - [Introduction to SQL](https://github.com/bobbyiliev/introduction-to-sql) - [Laravel tips and tricks](https://github.com/bobbyiliev/laravel-tips-and-tricks-ebook) +- [Introduction to Terraform](https://leanpub.com/introduction-to-terraform) +- [Introduction to Linux](https://leanpub.com/introduction-to-linux) ## 🤲 Contributing If you are contributing 🍿 please read the [contributing file](CONTRIBUTING.md) before submitting your pull requests. - - diff --git a/ebook/de/assets/cover.jpg b/ebook/de/assets/cover.jpg new file mode 100755 index 0000000..d6db238 Binary files /dev/null and b/ebook/de/assets/cover.jpg differ diff --git a/ebook/de/assets/cover.jpg-bak b/ebook/de/assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/de/assets/cover.jpg-bak differ diff --git a/ebook/de/assets/theme-dark.html b/ebook/de/assets/theme-dark.html new file mode 100644 index 0000000..6f12e6d --- /dev/null +++ b/ebook/de/assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/de/assets/theme-light.html b/ebook/de/assets/theme-light.html new file mode 100644 index 0000000..561b80c --- /dev/null +++ b/ebook/de/assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git "a/ebook/de/content/000-\303\274ber-den-autor.md" "b/ebook/de/content/000-\303\274ber-den-autor.md" new file mode 100644 index 0000000..25ab02c --- /dev/null +++ "b/ebook/de/content/000-\303\274ber-den-autor.md" @@ -0,0 +1,91 @@ +# Über das Buch + +* **Diese Version wurde am 20. Oktober 2022 veröffentlicht.** + +Dies ist eine Open-Source-Einführung in die Bash-Skripterstellung, die Ihnen helfen wird, die Grundlagen der Bash-Skripterstellung zu erlernen und mit dem Schreiben großartiger Bash-Skripte zu beginnen, die Ihnen helfen werden, Ihre täglichen SysOps-, DevOps- und Dev-Aufgaben zu automatisieren. Egal, ob Sie ein DevOps/SysOps-Ingenieur, Entwickler oder einfach nur ein Linux-Enthusiast sind, Sie können Bash-Skripte verwenden, um verschiedene Linux-Befehle zu kombinieren und lästige und sich wiederholende tägliche Aufgaben zu automatisieren, damit Sie sich auf produktivere und unterhaltsamere Dinge konzentrieren können. + +Das Handbuch ist für jeden geeignet, der als Entwickler, Systemadministrator oder DevOps-Ingenieur arbeitet und die Grundlagen der Bash-Skripterstellung erlernen möchte. + +In den ersten 13 Kapiteln geht es ausschließlich darum, solide Grundlagen der Bash-Skripterstellung zu erlernen, in den restlichen Kapiteln finden Sie dann Beispiele und Skripte aus der Praxis. + +## Über den Autor + +Mein Name ist Bobby Iliev, und ich arbeite seit 2014 als Linux DevOps Engineer. Ich bin ein begeisterter Linux-Liebhaber und Anhänger der Philosophie der Open-Source-Bewegung. Ich tue immer das, was ich nicht kann, um zu lernen, wie es geht, und ich glaube daran, Wissen zu teilen. + +Ich denke, es ist wichtig, immer professionell zu bleiben und sich mit guten Leuten zu umgeben, hart zu arbeiten und nett zu allen zu sein. Man muss immer mehr leisten als andere. Das ist das Zeichen eines wahren Profis. + +Für weitere Informationen besuchen Sie bitte meinen Blog unter [https://bobbyiliev.com](https://bobbyiliev.com), folgen Sie mir auf Twitter [@bobbyiliev_](https://twitter.com/bobbyiliev_) und [YouTube](https://www.youtube.com/channel/UCQWmdHTeAO0UvaNqve9udRw). + +## Sponsoren + +Dieses Buch wird durch diese fantastischen Unternehmen ermöglicht! + +### Materialize + +Die Streaming-Datenbank für Echtzeitanalysen. + +[Materialize](https://materialize.com/) ist eine reaktive Datenbank, die inkrementelle Ansichtsaktualisierungen liefert. Materialize hilft Entwicklern bei der einfachen Erstellung mit Streaming-Daten unter Verwendung von Standard-SQL. + +### DigitalOcean + +DigitalOcean ist eine Cloud-Service-Plattform, die Entwicklern die Einfachheit bietet, die sie lieben und auf die Unternehmen vertrauen, um Produktionsanwendungen in großem Umfang auszuführen. + +Sie bietet hochverfügbare, sichere und skalierbare Rechen-, Speicher- und Netzwerklösungen, die Entwicklern helfen, großartige Software schneller zu entwickeln. + +DigitalOcean wurde 2012 gegründet und verfügt über Niederlassungen in New York und Cambridge, MA. Das Unternehmen bietet transparente und erschwingliche Preise, eine elegante Benutzeroberfläche und eine der größten Bibliotheken mit Open-Source-Ressourcen. + +Für weitere Informationen besuchen Sie bitte [https://www.digitalocean.com](https://www.digitalocean.com) oder folgen Sie [@digitalocean](https://twitter.com/digitalocean) auf Twitter. + +Wenn Sie neu bei DigitalOcean sind, können Sie ein kostenloses Guthaben von 100 $ erhalten und Ihre eigenen Server über diesen Empfehlungslink hier einrichten: + +[Free $100 Credit For DigitalOcean](https://m.do.co/c/2a9bba940f39) + +### DevDojo + +Das DevDojo ist eine Ressource, um alles über Web-Entwicklung und Web-Design zu lernen. Lernen Sie in Ihrer Mittagspause oder wachen Sie auf und genießen Sie eine Tasse Kaffee mit uns, um etwas Neues zu lernen. + +Treten Sie dieser Entwickler-Community bei, und wir können alle gemeinsam lernen, gemeinsam entwickeln und gemeinsam wachsen. + +[DevDojo beitreten](https://devdojo.com?ref=bobbyiliev) + +Für weitere Informationen besuchen Sie bitte [https://www.devdojo.com](https://www.devdojo.com?ref=bobbyiliev) oder folgen Sie [@thedevdojo](https://twitter.com/thedevdojo) auf Twitter. + +## E-Book PDF Generation Tool + +Dieses E-Book wurde mit [Ibis](https://github.com/themsaid/ibis/) erstellt, entwickelt von [Mohamed Said](https://github.com/themsaid). + +Ibis ist ein PHP-Tool, mit dem Sie E-Books in Markdown schreiben können. + +## E-Book ePub Generierungswerkzeug + +Die ePub-Version wurde mit [Pandoc] (https://pandoc.org/) erstellt. + +## Buchdeckel + +Das Cover für dieses E-Book wurde mit [Canva.com](https://www.canva.com/join/determined-cork-learn) erstellt. + +Wenn Sie jemals eine Grafik, ein Poster, eine Einladung, ein Logo, eine Präsentation - oder irgendetwas anderes, das gut aussieht - erstellen müssen, probieren Sie Canva aus. + +## Lizenz + +MIT-Lizenz + +Urheberrecht (c) 2020 Bobby Iliev + +Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, die kostenlose Erlaubnis erteilt +dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, die Erlaubnis +der Software ohne Einschränkung zu handeln, einschließlich und ohne Einschränkung der Rechte +zu nutzen, zu kopieren, zu modifizieren, zusammenzuführen, zu veröffentlichen, zu vertreiben, zu unterlizenzieren und/oder zu verkaufen +der Software zu nutzen, zu kopieren, zu modifizieren, zu veröffentlichen, zu vertreiben, zu unterlizenzieren und/oder zu verkaufen, und +zu erlauben, dies zu tun, vorbehaltlich der folgenden Bedingungen: + +Der obige Copyright-Hinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein. +Kopien oder wesentlichen Teilen der Software enthalten sein. + +DIE SOFTWARE WIRD OHNE MÄNGELGEWÄHR UND OHNE JEGLICHE AUSDRÜCKLICHE ODER +ODER STILLSCHWEIGEND, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, +EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG VON RECHTEN DRITTER. IN KEINEM FALL SIND DIE +DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE +HAFTUNG, SEI ES AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE SICH AUS, +AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER NUTZUNG ODER DEM SONSTIGEN UMGANG MIT DER +SOFTWARE. diff --git "a/ebook/de/content/001-einf\303\274hrung-in-bash.md" "b/ebook/de/content/001-einf\303\274hrung-in-bash.md" new file mode 100644 index 0000000..f2789d6 --- /dev/null +++ "b/ebook/de/content/001-einf\303\274hrung-in-bash.md" @@ -0,0 +1,9 @@ +# Einführung in die Bash-Skripterstellung + +Willkommen zu diesem Bash-Grundlagen-Trainingshandbuch! In diesem **Bash-Crashkurs** lernen Sie die **Bash-Grundlagen** kennen, damit Sie Ihre eigenen Bash-Skripte schreiben und Ihre täglichen Aufgaben automatisieren können. + +Bash ist eine Unix-Shell und Befehlssprache. Sie ist auf verschiedenen Betriebssystemen weit verbreitet und ist auch der Standard-Befehlsinterpreter auf den meisten Linux-Systemen. + +Bash steht für Bourne-Again SHell. Wie andere Shells können Sie Bash interaktiv direkt in Ihrem Terminal verwenden, und Sie können Bash auch wie jede andere Programmiersprache zum Schreiben von Skripten verwenden. In diesem Buch lernen Sie die Grundlagen der Bash-Skripterstellung kennen, darunter Bash-Variablen, Benutzereingaben, Kommentare, Argumente, Arrays, bedingte Ausdrücke, Konditionale, Schleifen, Funktionen, Debugging und Tests. + +Um Bash-Skripte zu schreiben, benötigen Sie lediglich ein UNIX-Terminal und einen Texteditor wie Sublime Text, VS Code oder einen terminalbasierten Editor wie vim oder nano. diff --git a/ebook/de/content/002-bash-struktur.md b/ebook/de/content/002-bash-struktur.md new file mode 100644 index 0000000..b0fca30 --- /dev/null +++ b/ebook/de/content/002-bash-struktur.md @@ -0,0 +1,25 @@ +# Bash-Struktur + +Beginnen wir mit der Erstellung einer neuen Datei mit der Erweiterung `.sh`. Als Beispiel könnten wir eine Datei namens `devdojo.sh` erstellen. + +Um diese Datei zu erstellen, können Sie den Befehl `touch` verwenden: + +```bash +touch devdojo.sh +``` + +Oder Sie können stattdessen Ihren Texteditor verwenden: + +```bash +nano devdojo.sh +``` + +Um eine Bash-Skriptdatei mit dem Bash-Shell-Interpreter auszuführen, muss in der ersten Zeile einer Skriptdatei der absolute Pfad zur ausführbaren Bash-Datei angegeben werden: + +```bash +#!/bin/bash +``` + +Dies wird auch [Shebang] genannt (https://en.wikipedia.org/wiki/Shebang_(Unix)). + +Der Shebang weist das Betriebssystem lediglich an, das Skript mit der ausführbaren Datei `/bin/bash` auszuführen. diff --git a/ebook/de/content/003-bash-hello-world.md b/ebook/de/content/003-bash-hello-world.md new file mode 100644 index 0000000..10f23dd --- /dev/null +++ b/ebook/de/content/003-bash-hello-world.md @@ -0,0 +1,41 @@ +# Bash Hallo Welt + +Nachdem wir unsere `devdojo.sh`-Datei erstellt und den Bash-Shabang in der ersten Zeile angegeben haben, können wir unser erstes `Hello World`-Bash-Skript erstellen. + +Dazu öffnen wir die Datei `devdojo.sh` erneut und fügen nach der Zeile `#!/bin/bash` folgendes ein: + +```bash +#!/bin/bash + +echo "Hello World!" +``` + +Speichern Sie die Datei und beenden Sie sie. + +Danach machen Sie das Skript ausführbar, indem Sie es ausführen: + +```bash +chmod +x devdojo.sh +``` + +Danach führen Sie die Datei aus: + +```bash +./devdojo.sh +``` + +Sie werden eine "Hello World"-Meldung auf dem Bildschirm sehen. + +Eine andere Möglichkeit, das Skript auszuführen, wäre: + +```bash +bash devdojo.sh +``` + +Da bash interaktiv verwendet werden kann, könnten Sie den folgenden Befehl direkt in Ihrem Terminal ausführen und Sie würden das gleiche Ergebnis erhalten: + +```bash +echo "Hallo DevDojo!" +``` + +Das Zusammenstellen eines Skripts ist nützlich, wenn Sie mehrere Befehle miteinander kombinieren müssen. diff --git a/ebook/de/content/004-bash-variablen.md b/ebook/de/content/004-bash-variablen.md new file mode 100644 index 0000000..8acb3e8 --- /dev/null +++ b/ebook/de/content/004-bash-variablen.md @@ -0,0 +1,86 @@ +# Bash-Variablen + +Wie in jeder anderen Programmiersprache können Sie auch in Bash Scripting Variablen verwenden. Allerdings gibt es keine Datentypen, und eine Variable in der Bash kann sowohl Zahlen als auch Zeichen enthalten. + +Um einer Variablen einen Wert zuzuweisen, müssen Sie nur das `=` Zeichen verwenden: + +```bash +name="DevDojo" +``` + +>Beachten Sie, dass vor und nach dem `=`-Zeichen keine Leerzeichen stehen dürfen. + +Um danach auf die Variable zuzugreifen, müssen Sie das `$` Zeichen verwenden und auf sie verweisen, wie unten gezeigt: + +```bash +echo $name +``` + +Den Variablennamen in geschweifte Klammern einzuschließen ist nicht erforderlich, wird aber als gute Praxis angesehen, und ich würde Ihnen raten, sie zu verwenden, wann immer Sie können: + +```bash +echo ${name} +``` + +Der obige Code würde ausgeben: DevDojo", da dies der Wert unserer Variable "Name" ist. + +Als Nächstes wollen wir unser Skript `devdojo.sh` aktualisieren und eine Variable einfügen. + +Wiederum können Sie die Datei `devdojo.sh` mit Ihrem bevorzugten Texteditor öffnen, ich benutze hier nano, um die Datei zu öffnen: + +```bash +nano devdojo.sh +``` + +Füge unsere Variable `name` hier in die Datei ein, mit einer Willkommensnachricht. Unsere Datei sieht nun wie folgt aus: + +```bash +#!/bin/bash + +name="DevDojo" + +echo "Hallo, $name" +``` + +Speichern Sie die Datei und führen Sie sie mit dem folgenden Befehl aus: + +```bash +./devdojo.sh +``` + +Sie werden die folgende Ausgabe auf Ihrem Bildschirm sehen: + +```bash +Hallo, DevDojo +``` + +Hier ist ein Überblick über das Skript, das in die Datei geschrieben wurde: + +* `#!/bin/bash` - Als erstes haben wir unseren Shebang angegeben. +* `name=DevDojo` - Dann haben wir eine Variable namens `name` definiert und ihr einen Wert zugewiesen. +* `echo "Hallo $name"` - Schließlich geben wir den Inhalt der Variable als Willkommensnachricht auf dem Bildschirm aus, indem wir `echo` verwenden. + +Sie können auch mehrere Variablen in der Datei hinzufügen, wie unten gezeigt: + +```bash +#!/bin/bash + +name="DevDojo" +gruss="Hallo" + +echo "$gruß $name" +``` + +Speichern Sie die Datei und führen Sie sie erneut aus: + +```bash +./devdojo.sh +``` + +Auf Ihrem Bildschirm sehen Sie die folgende Ausgabe: + +```bash +Hallo DevDojo +``` + +Beachten Sie, dass Sie nicht unbedingt ein Semikolon `;` am Ende jeder Zeile hinzufügen müssen. Es funktioniert in beide Richtungen, ein bisschen wie bei anderen Programmiersprachen wie JavaScript! diff --git a/ebook/de/content/005-bash-nutzer-eingaben.md b/ebook/de/content/005-bash-nutzer-eingaben.md new file mode 100644 index 0000000..9cd2f3e --- /dev/null +++ b/ebook/de/content/005-bash-nutzer-eingaben.md @@ -0,0 +1,54 @@ +# Bash-Benutzereingabe + +Mit dem vorherigen Skript haben wir eine Variable definiert und den Wert der Variable mit `echo $name` auf dem Bildschirm ausgegeben. + +Jetzt machen wir weiter und fragen stattdessen den Benutzer nach einer Eingabe. Um dies zu tun, öffnen Sie die Datei mit Ihrem bevorzugten Texteditor und ändern Sie das Skript wie folgt + +```bash +#!/bin/bash + +echo "Wie lautet Ihr Name?" +read name + +echo "Hallo, $Name" +echo "Willkommen bei DevDojo!" +``` + +Das obige Beispiel fordert den Benutzer zur Eingabe auf und speichert diese Eingabe als String/Text in einer Variablen. + +Wir können dann die Variable verwenden und eine Nachricht an den Benutzer zurückgeben. + +Die Ausgabe des obigen Skripts wäre: + +* Starten Sie zuerst das Skript: + +```bash +./devdojo.sh +``` + +* Dann würden Sie aufgefordert werden, Ihren Namen einzugeben: + +``` +Wie lautet Ihr Name? +Bobby +``` + +* Nachdem Sie Ihren Namen eingegeben haben, drücken Sie einfach die Eingabetaste und Sie erhalten die folgende Ausgabe: + +``` +Hallo, Bobby +Willkommen bei DevDojo! +``` + +Um den Code zu reduzieren, koennten wir die erste `echo`-Anweisung durch `read -p` ersetzen. Der `read`-Befehl, der mit der `-p`-Flagge verwendet wird, gibt eine Nachricht aus, bevor er den Benutzer nach seiner Eingabe fragt: + +```bash +#!/bin/bash + +read -p "Wie ist Ihr Name? " Name + +echo "Hallo, $Name" +echo "Willkommen bei DevDojo!" +``` + +Testen Sie dies unbedingt auch selbst! \ No newline at end of file diff --git a/ebook/de/content/006-bash-kommentare.md b/ebook/de/content/006-bash-kommentare.md new file mode 100644 index 0000000..1eb4401 --- /dev/null +++ b/ebook/de/content/006-bash-kommentare.md @@ -0,0 +1,27 @@ +# Bash-Kommentare + +Wie in jeder anderen Programmiersprache auch können Sie Ihrem Skript Kommentare hinzufügen. Kommentare werden verwendet, um sich selbst Notizen in Ihrem Code zu hinterlassen. + +Um dies in der Bash zu tun, müssen Sie das Symbol `#` am Anfang der Zeile einfügen. Kommentare werden niemals auf dem Bildschirm angezeigt. + +Hier ist ein Beispiel für einen Kommentar: + +```bash +# Dies ist ein Kommentar und wird nicht auf dem Bildschirm angezeigt +``` + +Fügen wir nun unserem Skript einige Kommentare hinzu: + +```bash +#!/bin/bash + +# Frag den Benutzer nach seinem Namen + +read -p "Wie lautet Ihr Name? " Name + +# Begrüßt den Benutzer +echo "Hallo, $Name" +echo "Willkommen bei DevDojo!" +``` + +Kommentare sind eine großartige Möglichkeit, einige der komplexeren Funktionen direkt in Ihren Skripten zu beschreiben, so dass andere Leute sich leicht in Ihrem Code zurechtfinden können. \ No newline at end of file diff --git a/ebook/de/content/007-bash-argumente.md b/ebook/de/content/007-bash-argumente.md new file mode 100644 index 0000000..77cf2f8 --- /dev/null +++ b/ebook/de/content/007-bash-argumente.md @@ -0,0 +1,77 @@ +# Bash-Argumente + +Sie können Ihrem Shell-Skript Argumente übergeben, wenn Sie es ausführen. Um ein Argument zu übergeben, müssen Sie es einfach direkt hinter den Namen Ihres Skripts schreiben. Zum Beispiel: + +```bash +./devdojo.com ihr_argument +``` + +Im Skript können wir dann `$1` verwenden, um auf das erste Argument zu verweisen, das wir angegeben haben. + +Wenn wir ein zweites Argument übergeben, wäre es als `$2` verfügbar und so weiter. + +Lassen Sie uns als Beispiel ein kurzes Skript namens `arguments.sh` erstellen: + +```bash +#!/bin/bash + +echo "Argument eins ist $1" +echo "Argument zwei ist $2" +echo "Argument drei ist $3" +``` + +Speichern Sie die Datei und machen Sie sie ausführbar: + +```bash +chmod +x argumente.sh +``` + +Starten Sie dann die Datei und übergeben Sie **3** Argumente: + +```bash +./arguments.sh hund katze vogel +``` + +Die Ausgabe, die Sie erhalten würden, wäre: + +```bash +Argument eins ist Hund +Argument zwei ist Katze +Argument drei ist Vogel +``` + +Um alle Argumente zu referenzieren, können Sie `$@` verwenden: + +```bash +#!/bin/bash + +echo "Alle Argumente: $@" +``` + +Wenn Sie das Skript erneut ausführen: + +```bash +./arguments.sh dog cat bird +``` + +Sie werden die folgende Ausgabe erhalten: + +``` +Alle Argumente: Hund Katze Vogel +``` + +Eine weitere Sache, die Sie beachten müssen, ist, dass `$0` verwendet wird, um auf das Skript selbst zu verweisen. + +Dies ist ein ausgezeichneter Weg, um die Datei bei Bedarf selbst zu zerstören oder einfach den Namen des Skripts zu erhalten. + +Lassen Sie uns zum Beispiel ein Skript erstellen, das den Namen der Datei ausgibt und die Datei danach löscht: + +```bash +#!/bin/bash + +echo "Der Name der Datei ist: $0 und sie wird selbst geloescht." + +rm -f $0 +``` + +Sie müssen mit der Selbstlöschung vorsichtig sein und sicherstellen, dass Sie Ihr Skript gesichert haben, bevor Sie es selbst löschen. \ No newline at end of file diff --git a/ebook/de/content/008-bash-arrays.md b/ebook/de/content/008-bash-arrays.md new file mode 100644 index 0000000..dd08dc6 --- /dev/null +++ b/ebook/de/content/008-bash-arrays.md @@ -0,0 +1,112 @@ +# Bash Arrays + +Wenn Sie jemals programmiert haben, sind Sie wahrscheinlich bereits mit Arrays vertraut. + +Für den Fall, dass Sie kein Entwickler sind, sollten Sie vor allem wissen, dass Arrays, anders als Variablen, mehrere Werte unter einem Namen speichern können. + +Sie können ein Array initialisieren, indem Sie ihm Werte zuweisen, die durch ein Leerzeichen getrennt und in `()` eingeschlossen sind. Beispiel: + +```bash +mein_array=("Wert 1" "Wert 2" "Wert 3" "Wert 4") +``` + +Um auf die Elemente im Array zuzugreifen, müssen Sie sie über ihren numerischen Index referenzieren. + +>Beachten Sie, dass Sie geschweifte Klammern verwenden müssen. + +* Beim Zugriff auf ein einzelnes Element würde dies ausgegeben werden: `Wert 2` + +```bash +echo ${my_array[1]} +``` + +* Dies würde das letzte Element zurückgeben: `value 4` + +```bash +echo ${my_array[-1]} +``` + +* Wie bei den Kommandozeilenargumenten gibt die Verwendung von `@` alle Argumente im Array zurück, wie folgt: `Wert 1 Wert 2 Wert 3 Wert 4` + +```bash +echo ${my_array[@]} +``` + +* Wenn man dem Array ein Rautezeichen (`#`) voranstellt, wird die Gesamtzahl der Elemente im Array ausgegeben, in unserem Fall ist es `4`: + +```bash +echo ${#my_array[@]} +``` + +Testen Sie dies und üben Sie es bei Ihnen mit verschiedenen Werten. + +## Zeichenketten in der Bash :: Zerschneiden + +Schauen wir uns das folgende Beispiel für die Zerlegung einer Zeichenkette in der Bash an: + +```bash +#!/bin/bash + +Buchstaben=( "A""B""C""D""E" ) +echo ${Buchstaben[@]} +``` + +Dieser Befehl gibt alle Elemente eines Arrays aus. + +Ausgabe: + +```bash +$ ABCDE +``` + + +Sehen wir uns ein paar weitere Beispiele an: + +- Beispiel 1 + +```bash +#!/bin/bash + +Buchstaben=("A""B""C""D""E" ) +b=${Buchstaben:0:2} +echo "${b}" +``` + +Dieser Befehl druckt ein Array vom Startindex 0 bis 2, wobei 2 exklusiv ist. + +```bash +$ AB +``` + +- Beispiel 2 + +```bash +#!/bin/bash + +Buchstaben=("A""B""C""D""E" ) +b=${Buchstaben::5} +echo "${b}" +``` + +Dieser Befehl druckt von Basisindex 0 bis 5, wobei 5 exklusiv ist und der Startindex standardmäßig auf 0 gesetzt ist. + +```bash +$ ABCDE +``` + +- Beispiel 3 + +```bash +#!/bin/bash + +Buchstaben=("A""B""C""D""E" ) +b=${Buchstaben:3} +echo "${b}" +``` + +Dieser Befehl druckt vom Startindex +3 bis einschließlich Ende des Arrays aus. + + ```bash + $ DE + ``` diff --git "a/ebook/de/content/009-bash-bedingungs-ausdr\303\274cke.md" "b/ebook/de/content/009-bash-bedingungs-ausdr\303\274cke.md" new file mode 100644 index 0000000..d0a943a --- /dev/null +++ "b/ebook/de/content/009-bash-bedingungs-ausdr\303\274cke.md" @@ -0,0 +1,191 @@ +# Bash Bedingungs Ausdrücke + +In der Informatik sind Bedingungen fundamentale Merkmale von Programmiersprachen, die verschiedene Berechnungen oder Aktionen durchführen, +je nachdem, ob eine vom Programmierer festgelegte boolesche Bedingung als wahr oder falsch bewertet wird. + +In Bash werden Bedingungen vom `[[` zusammengesetzten Befehl und den `[`eingebauten Befehlen verwendet, um Dateiattribute zu testen und String- +und arithmetische Vergleiche durchzuführen. + +Hier ist eine Liste der gängigsten Bedingungen in Bash. Sie müssen sie nicht auswendig lernen. Sie können einfach auf diese Liste zurückgreifen, +wann immer Sie sie brauchen! + +## Datei + +* True, sofern die Datei existiert. + +```bash +[[ -a ${file} ]] +``` + +* True, sofern die Datei existiert und eine spezielle Blockdatei ist. + +```bash +[[ -b ${file} ]] +``` + +* True, sofern die Datei existiert und eine spezielle Zeichendatei ist. + +```bash +[[ -c ${file} ]] +``` + +* True, sofern der Ordner existiert. + +```bash +[[ -d ${file} ]] +``` + +* True, sofern die Datei existiert. + +```bash +[[ -e ${file} ]] +``` + +* True, sofern die Datei existiert und eine reguläre Datei ist. + +```bash +[[ -f ${file} ]] +``` + +* True, sofern die Datei existiert und ein symbolischer Link ist. + +```bash +[[ -h ${file} ]] +``` + +* True, sofern die Datei existiert und lesbar ist. + +```bash +[[ -r ${file} ]] +``` + +* True, sofern die Datei größer als 0 ist + +```bash +[[ -s ${file} ]] +``` + +* True, sofern die Datei existiert und beschreibbar ist. + +```bash +[[ -w ${file} ]] +``` + +* True, sofern die Datei existiert und ausführbar ist. + +```bash +[[ -x ${file} ]] +``` + +* True, sofern die Datei existiert und ein symbolischer Link ist. + +```bash +[[ -L ${file} ]] +``` + +## String ausdrücke + +* True, sofern die shell Variable existiert + +```bash +[[ -v ${varname} ]] +``` + +* True, sofern die Länge des Strings 0 ist. + +```bash +[[ -z ${string} ]] +``` + +* True, sofern die Länge des Strings nicht 0 ist. + +```bash +[[ -n ${string} ]] +``` + +* True if the strings are equal. `=` should be used with the test command for POSIX conformance. When used with the `[[` command, this performs pattern matching as described above (Compound Commands). + +* True, sofern die String gleich sind. `=` sollte mit dem test Befehl für POSIX Konformität verwendet werden. Bei Verwendung mit dem Befehl `[[` wird der Mustervergleich wie oben beschrieben durchgeführt (Zusammengesetzte Befehle). + +```bash +[[ ${string1} == ${string2} ]] +``` + +* True, sofern die Strings nicht gleich sind. + +```bash +[[ ${string1} != ${string2} ]] +``` + +* True, sofern string1 vor string2 lexikografisch sortiert ist. + +```bash +[[ ${string1} < ${string2} ]] +``` + +* True, sofern string1 nach string2 lexikografisch sortiert ist. + +```bash +[[ ${string1} > ${string2} ]] +``` + +## Arithmetische Operatoren + +* True, wenn die Zahlen **gleich** sind + +```bash +[[ ${arg1} -eq ${arg2} ]] +``` + +* True, wenn die Zahlen **nicht gleich** sind + +```bash +[[ ${arg1} -ne ${arg2} ]] +``` + +* True, wenn arg1 **kleiner als** arg2 ist + +```bash +[[ ${arg1} -lt ${arg2} ]] +``` + +* True, wenn arg1 **kleiner oder gleich** arg2 ist + +```bash +[[ ${arg1} -le ${arg2} ]] +``` + +* True, wenn arg1 **größer als** arg2´ist + +```bash +[[ ${arg1} -gt ${arg2} ]] +``` + +* True, wenn arg1 **größer oder gleich** arg2 ist + +```bash +[[ ${arg1} -ge ${arg2} ]] +``` + +Als Randnotiz, arg1 und arg2 können sowohl positiv als auch negativ sein. + +Wie in anderen Programmiersprachen auch, kann man auch `AND` & `OR` verwenden + +```bash +[[ test_case_1 ]] && [[ test_case_2 ]] # Und/And +[[ test_case_1 ]] || [[ test_case_2 ]] # Oder/Or +``` + +## Exit status operatoren + +* True, wenn der Befehl ohne erfolgreich ohne Fehler war + +```bash +[[ $? -eq 0 ]] +``` + +* True, wenn der Befehl nicht erfolgreich war und Fehler aufwies + +```bash +[[ $? -gt 0 ]] +``` diff --git a/ebook/de/content/010-bash-bedingungen.md b/ebook/de/content/010-bash-bedingungen.md new file mode 100644 index 0000000..b0ebac9 --- /dev/null +++ b/ebook/de/content/010-bash-bedingungen.md @@ -0,0 +1,187 @@ +# Bash Bedingungen + +Im letzten Abschnitt haben wir einige der gängigsten Bedingungs-Ausdrücke behandelt. Wir können sie nun mit Standard-Bedingungsanweisungen wie `if`, `if-else` und `switch case`-Anweisungen verwenden. + +## If statement + +Das Format einer "if"-Anweisung in Bash ist wie folgt: + +```bash +if [[ some_test ]] +then + +fi +``` + +Hier ist ein kurzes Beispiel, das Sie auffordert, Ihren Namen einzugeben, falls Sie ihn leer gelassen haben: + +```bash +#!/bin/bash + +# Bash if statement beispiel + +read -p "Wie heißt du? " name + +if [[ -z ${name} ]] +then + echo "Bitte gebe deinen Namen ein!" +fi +``` + +## If Else statement + +Mit einer `if-else`-Anweisung können Sie eine Aktion für den Fall angeben, dass die Bedingung in der `if`-Anweisung nicht erfüllt ist. Wir können dies mit den bedingten Ausdrücken aus dem vorherigen Abschnitt wie folgt kombinieren: + +```bash +#!/bin/bash + +# Bash if statement example + +read -p "Wie heißt du? " name + +if [[ -z ${name} ]] +then + echo "Bitte gebe deinen Namen ein!" +else + echo "Hey ${name}" +fi +``` + +Sie können die obige if-Anweisung mit allen Bedinunges-Ausdrücken aus den vorherigen Kapiteln verwenden: + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Bitte gebe den Nutzernamen ein " username + +# Überprüfen ob der eingegebene Benutzername der Administrator ist + +if [[ "${username}" == "${admin}" ]] ; then + echo "Du bist der Admin!" +else + echo "Du bist NICHT der Admin!" +fi +``` + +Hier ist ein weiteres Beispiel für eine `if `-Anweisung, die Ihre aktuelle `Benutzer-ID ` überprüft und Ihnen nicht erlaubt, das Skript als `root `-Benutzer auszuführen: + +```bash +#!/bin/bash + +if (( $EUID == 0 )); then + echo "Bitte führe das Skript nicht als root aus" + exit +fi +``` + +Wenn Sie dies an den Anfang Ihres Skripts stellen, wird es beendet, wenn die EUID 0 ist, und führt den Rest des Skripts nicht aus. Dies wurde im [DigitalOcean-Community-Forum] (https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script) diskutiert. + +Sie können auch mehrere Bedingungen mit einer `if`-Anweisung testen. In diesem Beispiel wollen wir sicherstellen, dass der Benutzer weder der Admin-Benutzer noch der Root-Benutzer ist, um sicherzustellen, dass das Skript nicht zu viel Schaden anrichten kann. In diesem Beispiel verwenden wir den Operator `oder`, gekennzeichnet durch `||`. Das bedeutet, dass eine der beiden Bedingungen wahr sein muss. Wenn wir den `und` Operator von `&&` verwenden würden, müssten beide Bedingungen wahr sein. + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Bitte gebe den Nutzernamen ein? " username + +# Überprüfen ob der eingegebene Benutzername der Administrator ist + +if [[ "${username}" != "${admin}" ]] || [[ $EUID != 0 ]] ; then + echo "Du bist entweder nicht der Admin oder du bist der root Nutzer, bitte sicher bleiben" +else + echo "Du bist der Admin! Das könnte zerstörerisch werden" +fi +``` + +Wenn Sie mehrere Bedingungen und Szenarien haben, können Sie die `elif`-Anweisung mit `if`- und `else`-Anweisungen verwenden. + +```bash +#!/bin/bash + +read -p "Gebe eine Zahl ein: " num + +if [[ $num -gt 0 ]] ; then + echo "Die Zahl ist positiv" +elif [[ $num -lt 0 ]] ; then + echo "Die Zahl ist negativ" +else + echo "Die Zahl ist 0" +fi +``` + +## Switch case statements + +Wie in anderen Programmiersprachen können Sie eine `Case`-Anweisung verwenden, um komplexe Bedingungen zu vereinfachen, wenn es mehrere verschiedene Möglichkeiten gibt. Anstatt also mehrere `if`- und `if-else`-Anweisungen zu verwenden, können Sie eine einzige `case`-Anweisung benutzen. + +Die Syntax der Bash `case`-Anweisung sieht wie folgt aus: + +```bash +case $some_variable in + + pattern_1) + commands + ;; + + pattern_2| pattern_3) + commands + ;; + + *) + default commands + ;; +esac +``` + +Ein kurzer Überblick über die Struktur: + +* Alle `case`-Anweisungen beginnen mit dem Schlüsselwort `case`. +* In derselben Zeile wie das Schlüsselwort "case" müssen Sie eine Variable oder einen Ausdruck angeben, gefolgt von dem Schlüsselwort `in`. +* Danach folgen die `case`-Muster, wobei Sie mit `)` das Ende des Musters angeben müssen. +* Sie können mehrere Muster angeben, die durch eine Pipe getrennt sind: `|`. +* Nach dem Muster geben Sie die Befehle an, die ausgeführt werden sollen, wenn das Muster auf die angegebene Variable oder den Ausdruck passt. +* Alle Klauseln müssen durch das Anfügen von `;;` am Ende abgeschlossen werden. +* Sie können eine Standardanweisung haben, indem Sie ein `*` als Muster hinzufügen. +* Um die `case`-Anweisung zu schließen, verwenden Sie das Schlüsselwort `esac` (case typed backwards). + +Hier ist ein Beispiel für eine Bash `case`-Anweisung: + +```bash +#!/bin/bash + +read -p "Gebe den Namen einer Automarke ein: " car + +case $car in + + Tesla) + echo -n "${car}'s fabrik steht in der USA." + ;; + + BMW | Mercedes | Audi | Porsche) + echo -n "${car}' fabrik steht in Deutschland." + ;; + + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "${car}'s fabrik steht in Japan." + ;; + + *) + echo -n "${car} ist keine uns bekannte Automarke" + ;; + +esac +``` + +In diesem Skript wird der Benutzer aufgefordert, den Namen einer Automarke wie Telsa, BMW, Mercedes usw. einzugeben. + +Mit einer `Case`-Anweisung prüfen wir dann, ob der Markenname mit einem unserer Muster übereinstimmt, und wenn ja, geben wir den Standort der Fabrik aus. + +Wenn der Markenname mit keiner unserer `case`-Anweisungen übereinstimmt, geben wir eine Standardmeldung aus: `eine unbekannte Automarke`. + +## Zusammenfassung + +Ich würde Ihnen raten, das Skript zu modifizieren und ein wenig damit zu spielen, damit Sie das, was Sie in den letzten beiden Kapiteln gelernt haben, üben können! + +Weitere Beispiele für `case`-Anweisungen in der Bash finden Sie in Kapitel 16, in dem wir ein interaktives Menü in der Bash erstellen, das eine `cases`-Anweisung zur Verarbeitung der Benutzereingaben verwendet. diff --git a/ebook/de/content/011-bash-schleifen.md b/ebook/de/content/011-bash-schleifen.md new file mode 100644 index 0000000..4109b8c --- /dev/null +++ b/ebook/de/content/011-bash-schleifen.md @@ -0,0 +1,199 @@ +# Bash Schleifen + +Wie in jeder anderen Sprache, sind Schleifen sehr praktisch. Mit Bash können sie `for`, `while` und `until` Schleifen verwenden. + +## For Schleifen + +Hier ist die Struktur einer `for` Schleife: + +```bash +for var in ${list} +do + ihre_befehle +done +``` + +Beispiel: + +```bash +#!/bin/bash + +users="devdojo bobby tony" + +for user in ${users} +do + echo "${user}" +done +``` + +Eine kurze Zusammenfassung des Beispiels: + +- Zuallererst erstellen wir eine Liste von Benutzern und speichern sie in einer Variable welche wir als `users` bezeichnen. +- Dann starten wir unsere `for` Schleife mit dem `for` Befehl. +- Danach definieren wir eine Variable, welche jeden Eintrag in der `users` Variable darstellt. In unserem Fall definieren wir eine Variable mit dem Namen `user`, welche jeden einzelnen Benutzer in der `users` Variable repraesentiert. +- Dann geben wir das Schlüsselwort `in` an, gefolgt von unserer Liste, die wir durchlaufen. +- In der nächsten Zeile verwenden wir das Schlüsselwort `do`, das angibt, was wir für jede Iteration der Schleife tun werden. +- Dann geben wir die Befehle an, die wir ausführen möchten. +- Abschließend schließen wir die Schleife mit dem Schlüsselwort `done`. + +Sie können `for` auch verwenden, um eine Reihe von Zahlen zu verarbeiten. Hier ist zum Beispiel eine Möglichkeit, von 1 bis 10 zu durchlaufen: + +```bash +#!/bin/bash + +for num in {1..10} +do + echo ${num} +done +``` + +## While Schleifen + +Der Aufbau einer while-Schleife ist der `for`-Schleife recht ähnlich: + +```bash +while [ ihre_bedingung ] +do + ihre_befehle +done +``` + +Hier ist ein Beispiel für eine `while`-Schleife: + +```bash +#!/bin/bash + +counter=1 +while [[ $counter -le 10 ]] +do + echo $counter + ((counter++)) +done +``` + +Zuerst haben wir eine Zählervariable angegeben und auf „1“ gesetzt, dann haben wir innerhalb der Schleife einen Zähler hinzugefügt, indem wir diese Anweisung hier verwendet haben: `((counter++))`. Auf diese Weise stellen wir sicher, dass die Schleife nur 10 Mal und nicht ewig ausgeführt wird. Die Schleife wird abgeschlossen, sobald der Zähler 10 erreicht, da wir dies als Bedingung festgelegt haben: `while [[ $counter -le 10 ]]`. + +Erstellen wir ein Skript, das den Benutzer nach seinem Namen fragt und keine leere Eingabe zulässt: + +```bash +#!/bin/bash + +read -p "Wie ist ihr Name? " name + +while [[ -z ${name} ]] +do + echo "Ihr Name darf nicht leer sein. Bitte geben Sie einen gültigen Namen ein!" + read -p "Geben Sie Ihren Namen erneut ein? " name +done + +echo "Hallo ${name}" +``` + +Wenn Sie nun das oben Gesagte ausführen und einfach die Eingabetaste drücken, ohne eine Eingabe vorzunehmen, läuft die Schleife erneut und fragt Sie immer wieder nach Ihrem Namen, bis Sie tatsächlich eine Eingabe machen. + +## Until Schleifen + +Der Unterschied zwischen `until`- und `while`-Schleifen besteht darin, dass die `until`-Schleife die Befehle innerhalb der Schleife ausführt, bis die Bedingung wahr wird. + +Struktur: + +```bash +until [[ ihre_bedingung ]] +do + ihre_befehle +done +``` + +Beispiel: + +```bash +#!/bin/bash + +count=1 +until [[ $count -gt 10 ]] +do + echo $count + ((count++)) +done +``` + +## Continue und Break + +Wie bei anderen Sprachen können Sie auch bei Ihren Bash-Skripten `continue` und `break` verwenden: + +- `continue` weist Ihr Bash-Skript an, die aktuelle Iteration der Schleife zu stoppen und die nächste Iteration zu starten. + +Die Syntax der continue-Anweisung lautet wie folgt: + +```bash +continue [n] +``` + +Das Argument [n] ist optional und kann größer oder gleich 1 sein. Wenn [n] angegeben wird, wird die n-te umschließende Schleife fortgesetzt. continue 1 ist gleichbedeutend mit continue. + +```bash +#!/bin/bash + +for i in 1 2 3 4 5 +do + if [[ $i –eq 2 ]] + then + echo "ueberspringe nummer 2" + continue + fi + echo "i ist gleich $i" +done +``` + +Wir können den Continue-Befehl auch auf ähnliche Weise wie den Break-Befehl verwenden, um mehrere Schleifen zu steuern. + +- `break` weist Ihr Bash-Skript an, die Schleife sofort zu beenden. + +Die Syntax der break-Anweisung sieht wie folgt aus: + +```bash +break [n] +``` + +[n] ist ein optionales Argument und muss größer oder gleich 1 sein. Wenn [n] angegeben wird, wird die n-te umschließende Schleife verlassen. Pause 1 entspricht Pause. + +Beispiel: + +```bash +#!/bin/bash + +num=1 +while [[ $num –lt 10 ]] +do + if [[ $num –eq 5 ]] + then + break + fi + ((num++)) +done +echo "Schleife abgeschlossen" +``` + +Wir können den Befehl break auch mit mehreren Schleifen verwenden. Wenn wir die aktuelle Arbeitsschleife verlassen möchten, egal ob innere oder äußere Schleife, verwenden wir einfach break. Wenn wir uns jedoch in der inneren Schleife befinden und die äußere Schleife verlassen möchten, verwenden wir break 2. + +Beispiel: + +```bash +#!/bin/bash + +for (( a = 1; a < 10; a++ )) +do + echo "Schleife außen: $a" + for (( b = 1; b < 100; b++ )) + do + if [[ $b –gt 5 ]] + then + break 2 + fi + echo "Schleife innen: $b " + done +done +``` + +Das Bash-Skript beginnt mit a=1 und wechselt zur inneren Schleife. Wenn es b=5 erreicht, wird die äußere Schleife unterbrochen. +Wir können nur `break` anstelle von `break 2` verwenden, um die innere Schleife zu unterbrechen und zu sehen, wie sich dies auf die Ausgabe auswirkt. diff --git a/ebook/de/content/012-bash-funktionen.md b/ebook/de/content/012-bash-funktionen.md new file mode 100644 index 0000000..a9bbfe6 --- /dev/null +++ b/ebook/de/content/012-bash-funktionen.md @@ -0,0 +1,66 @@ +# Bash Funktionen + +Funktionen sind eine großartige Möglichkeit, Code wiederzuverwenden. Die Struktur einer Funktion in Bash ist den meisten Sprachen ziemlich ähnlich: + +```bash +function funktion_name() { + ihre_befehle +} +``` + +Sie können das Schlüsselwort „function“ auch am Anfang weglassen, was ebenfalls funktionieren würde: + +```bash +funktion_name() { + ihre_befehle +} +``` + +Ich bevorzuge, es dort zu platzieren, um die Lesbarkeit zu verbessern. Aber es ist eine Frage der persönlichen Präferenz. + +Beispiel einer „Hello World!“ Funktion: + +```bash +#!/bin/bash + +function hello() { + echo "Hello World Function!" +} + +hello +``` + +> {notice} Beachten Sie, dass Sie beim Aufruf der Funktion keine Klammern hinzufügen sollten. + +Die Übergabe von Argumenten an eine Funktion funktioniert auf die gleiche Weise, wie die Übergabe von Argumenten an ein Skript: + +```bash +#!/bin/bash + +function hello() { + echo "Hello $1!" +} + +hello DevDojo +``` + +Funktionen sollten Kommentare enthalten, in denen Beschreibung, globale Variablen, Argumente, Ausgaben und ggf. zurückgegebene Werte erwähnt werden. (Kommentare werden i.d.R. in Englisch verfasst, weshalb das Beispiel so beibehalten wird) + +```bash +####################################### +# Description: Hello Function +# Globals: +# None +# Arguments: +# Single input argument +# Outputs: +# Value of input argument +# Returns: +# 0 if successful, non-zero on error. +####################################### +function hello() { + echo "Hello $1!" +} +``` + +In den nächsten Kapiteln werden wir häufig Funktionen verwenden! diff --git a/ebook/de/content/013-debuggen-und-testen.md b/ebook/de/content/013-debuggen-und-testen.md new file mode 100644 index 0000000..e6c0ac1 --- /dev/null +++ b/ebook/de/content/013-debuggen-und-testen.md @@ -0,0 +1,83 @@ +# Debuggen, Testen und Abkürzungen + +Um Ihre Bash-Skripte zu debuggen, können Sie beim Ausführen Ihrer Skripte `-x` verwenden: + +```bash +bash -x ./ihr_script.sh +``` + +Oder Sie können `set -x` vor der spezifischen Zeile hinzufügen, die Sie debuggen möchten. `set -x` aktiviert einen Modus der Shell, in dem alle ausgeführten Befehle auf dem Terminal ausgegeben werden. + +Eine weitere Möglichkeit, Ihre Skripte zu testen, ist die Verwendung dieses fantastischen Tools hier: + +[https://www.shellcheck.net/](https://www.shellcheck.net/) + +Kopieren Sie einfach Ihren Code und fügen Sie ihn in das Textfeld ein. Das Tool gibt Ihnen dann einige Vorschläge, wie Sie Ihr Skript verbessern können. + +Sie können das Tool auch direkt in Ihrem Terminal ausführen: + +[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck) + +Wenn Ihnen das Tool gefällt, stellen Sie sicher, dass Sie es auf GitHub mit einem Stern versehen und Ihren Beitrag leisten! + +Als SysAdmin/DevOps verbringe ich einen Großteil meines Tages im Terminal. Hier sind meine Lieblingsverknüpfungen, die mir helfen, Aufgaben schneller zu erledigen, während ich Bash-Skripte schreibe oder einfach nur im Terminal arbeite. + +Die beiden folgenden sind besonders nützlich, wenn Sie einen sehr langen Befehl haben. + +- Löschen Sie alles vom Cursor bis zum Ende der Zeile: + +``` +Strg + k +``` + +- Löschen Sie alles vom Cursor bis zum Ende der Zeile: + +``` +Strg + u +``` + +- Ein Wort rückwärts vom Cursor löschen: + +``` +Strg + w +``` + +- Durchsuchen Sie Ihren Verlauf rückwärts. Dies ist wahrscheinlich die, die ich am häufigsten verwende. Es ist wirklich praktisch und beschleunigt meinen Arbeitsablauf ungemein: + +``` +Strg + r +``` + +- Löschen Sie den Bildschirm. Ich verwende Folgendes, anstatt den Befehl `clear` einzugeben: + +``` +Strg + l +``` + +- Stoppt die Ausgabe auf dem Bildschirm: + +```Strg +Strg + s +``` + +- Aktivieren Sie die Ausgabe auf dem Bildschirm, falls diese zuvor mit `Strg + s` gestoppt wurde: + +``` +Strg + q +``` + +- Beenden Sie den aktuellen Befehl: + +``` +Strg + c +``` + +- Werfen Sie den aktuellen Befehl in den Hintergrund: + +``` +Strg + z +``` + +Ich verwende sie regelmäßig jeden Tag und spare dadurch viel Zeit. + +Wenn Sie der Meinung sind, dass ich etwas ausgelassen habe, können Sie sich gerne an der Diskussion im [DigitalOcean-Community-Forum](https://www.digitalocean.com/community/questions/what-are-your-favorite-bash-shortcuts) beteiligen! diff --git a/ebook/de/content/014-erstellen-benutzerdefinierter-bash-befehle.md b/ebook/de/content/014-erstellen-benutzerdefinierter-bash-befehle.md new file mode 100644 index 0000000..04ac039 --- /dev/null +++ b/ebook/de/content/014-erstellen-benutzerdefinierter-bash-befehle.md @@ -0,0 +1,85 @@ +# Erstellen benutzerdefinierter Bash-Befehle + +Als Entwickler oder Systemadministrator müssen Sie möglicherweise viel Zeit an Ihrem Terminal verbringen. Ich versuche immer, nach Möglichkeiten zu suchen, sich wiederholende Aufgaben zu optimieren. + +Eine Möglichkeit hierfür besteht darin, entweder kurze Bash-Skripte zu schreiben oder benutzerdefinierte Befehle, auch Aliase genannt, zu erstellen. Anstatt beispielsweise jedes Mal einen wirklich langen Befehl einzugeben, könnten Sie einfach eine Abkürzung dafür erstellen. + +## Beispiel + +Beginnen wir mit dem folgenden Szenario: Als Systemadministrator müssen Sie möglicherweise häufig die Verbindungen zu Ihrem Webserver überprüfen, daher verwende ich den Befehl `netstat` als Beispiel. + +Wenn ich auf einen Server zugreife, der Probleme mit den Verbindungen zu Port 80 oder 443 hat, prüfe ich normalerweise, ob Dienste diese Ports überwachen und wie viele Verbindungen zu diesen Ports bestehen. + +Der folgende `netstat`-Befehl würde uns zeigen, wie viele TCP-Verbindungen auf Port 80 und 443 wir derzeit haben: + +```bash +netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l +``` + +Dies ist ein ziemlich langer Befehl, daher kann es auf lange Sicht zeitaufwändig sein, ihn jedes Mal einzugeben, insbesondere wenn Sie diese Informationen schnell erhalten möchten. + +Um dies zu vermeiden, können wir einen Alias erstellen, sodass wir statt des gesamten Befehls einfach einen kurzen Befehl eingeben können. Nehmen wir zum Beispiel an, wir wollten in der Lage sein, `conn` (Abkürzung für 'Connections') einzugeben und die gleichen Informationen zu erhalten. In diesem Fall müssen wir lediglich den folgenden Befehl ausführen: + +```bash +alias conn="netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Auf diese Weise erstellen wir einen Alias namens `conn`, der im Wesentlichen eine 'Abkürzung' für unseren langen `netstat`-Befehl wäre. Wenn Sie jetzt einfach `conn` ausführen: + +```bash +conn +``` + +Sie würden die gleiche Ausgabe erhalten wie der lange Befehl `netstat`. +Sie können noch kreativer werden und hier einige Infobotschaften wie diese hinzufügen: + +```bash +alias conn="echo 'Total connections on port 80 and 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Wenn Sie nun `conn` ausführen, erhalten Sie die folgende Ausgabe: + +```bash +Total connections on port 80 and 443: +12 +``` + +Wenn Sie sich jetzt abmelden und wieder anmelden, geht Ihr Alias verloren. Im nächsten Schritt erfahren Sie, wie Sie dies dauerhaft machen. + +## Die Veränderung dauerhaft machen + +Um die Änderung dauerhaft zu machen, müssen wir den Befehl `alias` in unsere Shell-Profildatei einfügen. + +Standardmäßig wäre dies unter Ubuntu die Datei `~/.bashrc`, bei anderen Betriebssystemen könnte dies die Datei `~/.bash_profile` sein. Öffnen Sie die Datei mit Ihrem bevorzugten Texteditor: + +```bash +nano ~/.bashrc +``` + +Gehen Sie nach unten und fügen Sie Folgendes hinzu: + +```bash +alias conn="echo 'Total connections on port 80 and 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Speichern und dann beenden. + +Auf diese Weise bleibt Ihre Änderung auch dann erhalten, wenn Sie sich abmelden und wieder anmelden, und Sie können Ihren benutzerdefinierten Bash-Befehl ausführen. + +## Auflistung aller verfügbaren Aliase + +Um alle verfügbaren Aliase für Ihre aktuelle Shell aufzulisten, müssen Sie einfach den folgenden Befehl ausführen: + +```bash +alias +``` + +Dies ist nützlich, falls bei einigen Befehlen ein seltsames Verhalten auftritt. + +## Fazit + +Dies ist eine Möglichkeit, benutzerdefinierte Bash-Befehle oder Bash-Aliase zu erstellen. + +Natürlich könnten Sie tatsächlich ein Bash-Skript schreiben und das Skript in Ihrem Ordner `/usr/bin` hinzufügen, aber das würde nicht funktionieren, wenn Sie keinen Root- oder Sudo-Zugriff haben. Wobei es mit der oben genannten Möglichkeit ohne Notwendigkeit eines Root-Zugriffs funktioniert. + +> {notice} Dies wurde ursprünglich auf [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-create-custom-bash-commands) veröffentlicht. diff --git a/ebook/de/epub.yml b/ebook/de/epub.yml new file mode 100644 index 0000000..c18e03d --- /dev/null +++ b/ebook/de/epub.yml @@ -0,0 +1,14 @@ +--- +# Generate an ePub by running: +# pandoc content/*.md epub.yml -o export/introduction-to-bash-scripting.epub +title: Introduction to Bash Scripting +author: Bobby Iliev +cover-image: ./ebook/en/assets/cover.jpg +rights: MIT License +lang: en-US +tags: [bash, Unix, Linux] + +# Filter preferences: +# - pandoc-crossref +linkReferences: true +--- \ No newline at end of file diff --git a/ebook/de/ibis.php b/ebook/de/ibis.php new file mode 100644 index 0000000..2eb0509 --- /dev/null +++ b/ebook/de/ibis.php @@ -0,0 +1,34 @@ + 'Introduction to Bash Scripting', + + /** + * The author name. + */ + 'author' => 'Bobby Iliev', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'This is a sample from "Introduction to Bash Scripting" by Bobby Iliev.
+ For more information, Click here.', +]; diff --git a/ebook/en/content/000-about-the-author.md b/ebook/en/content/000-about-the-author.md index 526832b..34b5b86 100644 --- a/ebook/en/content/000-about-the-author.md +++ b/ebook/en/content/000-about-the-author.md @@ -1,6 +1,6 @@ # About the book -* **This version was published on Feb 01 2021** +* **This version was published on 02 08 2024** This is an open-source introduction to Bash scripting guide that will help you learn the basics of Bash scripting and start writing awesome Bash scripts that will help you automate your daily SysOps, DevOps, and Dev tasks. No matter if you are a DevOps/SysOps engineer, developer, or just a Linux enthusiast, you can use Bash scripts to combine different Linux commands and automate tedious and repetitive daily tasks so that you can focus on more productive and fun things. @@ -20,6 +20,12 @@ For more information, please visit my blog at [https://bobbyiliev.com](https://b This book is made possible thanks to these fantastic companies! +### Materialize + +The Streaming Database for Real-time Analytics. + +[Materialize](https://materialize.com/) is a reactive database that delivers incremental view updates. Materialize helps developers easily build with streaming data using standard SQL. + ### DigitalOcean DigitalOcean is a cloud services platform delivering the simplicity developers love and businesses trust to run production applications at scale. @@ -30,9 +36,9 @@ Founded in 2012 with offices in New York and Cambridge, MA, DigitalOcean offers For more information, please visit [https://www.digitalocean.com](https://www.digitalocean.com) or follow [@digitalocean](https://twitter.com/digitalocean) on Twitter. -If you are new to DigitalOcean, you can get a free $100 credit and spin up your own servers via this referral link here: +If you are new to DigitalOcean, you can get a free $200 credit and spin up your own servers via this referral link here: -[Free $100 Credit For DigitalOcean](https://m.do.co/c/2a9bba940f39) +[Free $200 Credit For DigitalOcean](https://m.do.co/c/2a9bba940f39) ### DevDojo @@ -50,6 +56,10 @@ This ebook was generated by [Ibis](https://github.com/themsaid/ibis/) developed Ibis is a PHP tool that helps you write eBooks in markdown. +## Ebook ePub Generation Tool + +The ePub version was generated by [Pandoc](https://pandoc.org/). + ## Book Cover The cover for this ebook was created with [Canva.com](https://www.canva.com/join/determined-cork-learn). diff --git a/ebook/en/content/001-introduction-to-bash.md b/ebook/en/content/001-introduction-to-bash.md index 191ecfc..bc2d401 100644 --- a/ebook/en/content/001-introduction-to-bash.md +++ b/ebook/en/content/001-introduction-to-bash.md @@ -6,4 +6,6 @@ Bash is a Unix shell and command language. It is widely available on various ope Bash stands for Bourne-Again SHell. As with other shells, you can use Bash interactively directly in your terminal, and also, you can use Bash like any other programming language to write scripts. This book will help you learn the basics of Bash scripting including Bash Variables, User Input, Comments, Arguments, Arrays, Conditional Expressions, Conditionals, Loops, Functions, Debugging, and testing. -In order to write Bash scripts, you just need a UNIX terminal and a text editor like Sublime Text, VS Code, or a terminal-based editor like vim or nano. \ No newline at end of file +Bash scripts are great for automating repetitive workloads and can help you save time considerably. For example, imagine working with a group of five developers on a project that requires a tedious environment setup. In order for the program to work correctly, each developer has to manually set up the environment. That's the same and very long task (setting up the environment) repeated five times at least. This is where you and Bash scripts come to the rescue! So instead, you create a simple text file containing all the necessary instructions and share it with your teammates. And now, all they have to do is execute the Bash script and everything will be created for them. + +In order to write Bash scripts, you just need a UNIX terminal and a text editor like Sublime Text, VS Code, or a terminal-based editor like vim or nano. diff --git a/ebook/en/content/002-bash-structure.md b/ebook/en/content/002-bash-structure.md index f02f3a4..9cc7d59 100644 --- a/ebook/en/content/002-bash-structure.md +++ b/ebook/en/content/002-bash-structure.md @@ -22,4 +22,11 @@ In order to execute/run a bash script file with the bash shell interpreter, the This is also called a [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)). -All that the shebang does is to instruct the operating system to run the script with the `/bin/bash` executable. +All that the shebang does is to instruct the operating system to run the script with the `/bin/bash` executable. + +However, bash is not always in `/bin/bash` directory, particularly on non-Linux systems or due to installation as an optional package. Thus, you may want to use: + +```bash +#!/usr/bin/env bash +``` +It searches for bash executable in directories, listed in PATH environmental variable. diff --git a/ebook/en/content/004-bash-variables.md b/ebook/en/content/004-bash-variables.md index d21be46..df01e3d 100644 --- a/ebook/en/content/004-bash-variables.md +++ b/ebook/en/content/004-bash-variables.md @@ -1,6 +1,6 @@ # Bash Variables -As with any other programming language, you can use variables in Bash as well. However, there are no data types, and a variable in Bash can contain numbers and characters. +As in any other programming language, you can use variables in Bash Scripting as well. However, there are no data types, and a variable in Bash can contain numbers as well as characters. To assign a value to a variable, all you need to do is use the `=` sign: @@ -10,29 +10,29 @@ name="DevDojo" >{notice} as an important note, you can not have spaces before and after the `=` sign. -After that, to access the variable, you have to use the `$` and reference it like this: +After that, to access the variable, you have to use the `$` and reference it as shown below: ```bash echo $name ``` -Wrapping the variable name between curly brackets is not required but is considered good practice, and I would advise to use them whenever you can: +Wrapping the variable name between curly brackets is not required, but is considered a good practice, and I would advise you to use them whenever you can: ```bash echo ${name} ``` -The above would output: `DevDojo` as this is the value of our variable. +The above code would output: `DevDojo` as this is the value of our `name` variable. -Next, let's update our `devdojo.sh` script and include a variable. +Next, let's update our `devdojo.sh` script and include a variable in it. -Again, with your favorite text editor, open the file: +Again, you can open the file `devdojo.sh` with your favorite text editor, I'm using nano here to open the file: ```bash nano devdojo.sh ``` -And update the file, so it looks like this: +Adding our `name` variable here in the file, with a welcome message. Our file now looks like this: ```bash #!/bin/bash @@ -42,7 +42,7 @@ name="DevDojo" echo "Hi there $name" ``` -Save it and run it again: +Save it and run the file using the command below: ```bash ./devdojo.sh @@ -54,13 +54,13 @@ You would see the following output on your screen: Hi there DevDojo ``` -Here is a rundown of the script: +Here is a rundown of the script written in the file: -* `#!/bin/bash` - first, we specified our shebang -* `name=DevDojo` - then we defined a variable called `name` and assigned a value to it -* `echo "Hi there $name"` - finally we output the content of the variable on the screen by using `echo` +* `#!/bin/bash` - At first, we specified our shebang. +* `name=DevDojo` - Then, we defined a variable called `name` and assigned a value to it. +* `echo "Hi there $name"` - Finally, we output the content of the variable on the screen as a welcome message by using `echo` -You can also add multiple variables: +You can also add multiple variables in the file as shown below: ```bash #!/bin/bash @@ -71,7 +71,7 @@ greeting="Hello" echo "$greeting $name" ``` -Save it and run it again: +Save the file and run it again: ```bash ./devdojo.sh @@ -82,5 +82,50 @@ You would see the following output on your screen: ```bash Hello DevDojo ``` +Note that you don't necessarily need to add semicolon `;` at the end of each line. It works both ways, a bit like other programming language such as JavaScript! -Note that you don't necessarily need to add semicolon `;` at the end of each line. It would work both ways, a bit like in JavaScript! \ No newline at end of file + +You can also add variables in the Command Line outside the Bash script and they can be read as parameters: + +```bash +./devdojo.sh Bobby buddy! +``` +This script takes in two parameters `Bobby`and `buddy!` separated by space. In the `devdojo.sh` file we have the following: + +```bash +#!/bin/bash + +echo "Hello there" $1 + +``` +`$1` is the first input (`Bobby`) in the Command Line. Similarly, there could be more inputs and they are all referenced to by the `$` sign and their respective order of input. This means that `buddy!` is referenced to using `$2`. Another useful method for reading variables is the `$@` which reads all inputs. + +So now let's change the `devdojo.sh` file to better understand: + +```bash +#!/bin/bash + +echo "Hello there" $1 + +# $1 : first parameter + +echo "Hello there" $2 + +# $2 : second parameter + +echo "Hello there" $@ + +# $@ : all +``` +The output for: + +```bash +./devdojo.sh Bobby buddy! +``` +Would be the following: + +```bash +Hello there Bobby +Hello there buddy! +Hello there Bobby buddy! +``` diff --git a/ebook/en/content/007-bash-arguments.md b/ebook/en/content/007-bash-arguments.md index af6d2b7..87fe90c 100644 --- a/ebook/en/content/007-bash-arguments.md +++ b/ebook/en/content/007-bash-arguments.md @@ -77,79 +77,5 @@ rm -f $0 You need to be careful with the self deletion and ensure that you have your script backed up before you self-delete it. -## Substring in Bash :: Slicing - -Let's review the following example of slicing in a string in Bash: - -```bash -#!/bin/bash - -letters=( "A""B""C""D""E" ) -echo ${letters[@]} -``` - -This command will print all the elements of an array. - -Output: - -```bash -$ ABCDE -``` - - -Lets see a few more examples: - -- Example 1 - -```bash -#!/bin/bash - -letters=( "A""B""C""D""E" ) -b=${letters:0:2} -echo "${b}" -``` - -This command wil print array from starting index 0 to 2 where 2 is exclusive. - -```bash -$ AB -``` - - - Example 2 - -```bash -#!/bin/bash - -letters=( "A""B""C""D""E" ) -b=${letters::5} -echo "${b}" -``` - -This command will print from base index 0 to 5, where 5 is exclusive and starting index is default set to 0 . - -```bash -$ ABCDE -``` - -- Example 3 - -```bash -#!/bin/bash - -letters=( "A""B""C""D""E" ) -b=${letters:3} -echo "${b}" -``` - -This command will print from starting index - 3 to end of array inclusive . - - ```bash - $ DE - ``` - - - - diff --git a/ebook/en/content/008-bash-arrays.md b/ebook/en/content/008-bash-arrays.md index fd84a89..6242198 100644 --- a/ebook/en/content/008-bash-arrays.md +++ b/ebook/en/content/008-bash-arrays.md @@ -4,7 +4,7 @@ If you have ever done any programming, you are probably already familiar with ar But just in case you are not a developer, the main thing that you need to know is that unlike variables, arrays can hold several values under one name. -You can initialize an array by assigning values devided by space and enclosed in `()`. Example: +You can initialize an array by assigning values divided by space and enclosed in `()`. Example: ```bash my_array=("value 1" "value 2" "value 3" "value 4") @@ -26,7 +26,7 @@ echo ${my_array[1]} echo ${my_array[-1]} ``` -* As with command line arguments using `@` will return all arguments in the array, as follows: `value 1 value 2 value 3 value 4` +* As with command line arguments using `@` will return all elements in the array, as follows: `value 1 value 2 value 3 value 4` ```bash echo ${my_array[@]} @@ -39,3 +39,76 @@ echo ${#my_array[@]} ``` Make sure to test this and practice it at your end with different values. + +## Array Slicing + +While Bash doesn't support true array slicing, you can achieve similar results using a combination of array indexing and string slicing: + +```bash +#!/bin/bash + +array=("A" "B" "C" "D" "E") + +# Print entire array +echo "${array[@]}" # Output: A B C D E + +# Access a single element +echo "${array[1]}" # Output: B + +# Print a range of elements (requires Bash 4.0+) +echo "${array[@]:1:3}" # Output: B C D + +# Print from an index to the end +echo "${array[@]:3}" # Output: D E +``` + +When working with arrays, always use `[@]` to refer to all elements, and enclose the parameter expansion in quotes to preserve spaces in array elements. + +## String Slicing + +In Bash, you can extract portions of a string using slicing. The basic syntax is: + +```bash +${string:start:length} +``` + +Where: +- `start` is the starting index (0-based) +- `length` is the maximum number of characters to extract + +Let's look at some examples: + +```bash +#!/bin/bash + +text="ABCDE" + +# Extract from index 0, maximum 2 characters +echo "${text:0:2}" # Output: AB + +# Extract from index 3 to the end +echo "${text:3}" # Output: DE + +# Extract 3 characters starting from index 1 +echo "${text:1:3}" # Output: BCD + +# If length exceeds remaining characters, it stops at the end +echo "${text:3:3}" # Output: DE (only 2 characters available) +``` + +Note that the second number in the slice notation represents the maximum length of the extracted substring, not the ending index. This is different from some other programming languages like Python. In Bash, if you specify a length that would extend beyond the end of the string, it will simply stop at the end of the string without raising an error. + +For example: + +```bash +text="Hello, World!" + +# Extract 5 characters starting from index 7 +echo "${text:7:5}" # Output: World + +# Attempt to extract 10 characters starting from index 7 +# (even though only 6 characters remain) +echo "${text:7:10}" # Output: World! +``` + +In the second example, even though we asked for 10 characters, Bash only returns the 6 available characters from index 7 to the end of the string. This behavior can be particularly useful when you're not sure of the exact length of the string you're working with. diff --git a/ebook/en/content/009-bash-conditional-expressions.md b/ebook/en/content/009-bash-conditional-expressions.md index 48028e3..339f50d 100644 --- a/ebook/en/content/009-bash-conditional-expressions.md +++ b/ebook/en/content/009-bash-conditional-expressions.md @@ -85,9 +85,11 @@ Here is a list of the most popular Bash conditional expressions. You do not have * True if the shell variable varname is set (has been assigned a value). ```bash -[[ -v ${varname} ]] +[[ -v varname ]] ``` +> Here, `varname` is the name of the variable. The `-v` operator expects a variable name as an argument rather than a value, so if you pass `${varname}` instead of `varname`, the expression will return false. + True if the length of the string is zero. ```bash @@ -173,13 +175,13 @@ As with other programming languages you can use `AND` & `OR` conditions: ## Exit status operators -* returns true if the the command was successful without any errors +* returns true if the command was successful without any errors ```bash [[ $? -eq 0 ]] ``` -* returns true if the the command was not successful or had errors +* returns true if the command was not successful or had errors ```bash [[ $? -gt 0 ]] diff --git a/ebook/en/content/010-bash-conditionals.md b/ebook/en/content/010-bash-conditionals.md index 3b19984..a84a7cd 100644 --- a/ebook/en/content/010-bash-conditionals.md +++ b/ebook/en/content/010-bash-conditionals.md @@ -78,7 +78,7 @@ fi If you put this on top of your script it would exit in case that the EUID is 0 and would not execute the rest of the script. This was discussed on [the DigitalOcean community forum](https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script). -You can also test multiple conditions with an `if` statement. In this example we want to make sure that the user is neither the admin user or the root user to ensure the script is incapable of causing too much damage. We'll use the `or` operator in this example, noted by `||`. This means that either of the conditions needs to be true. If we used the `and` operator of `&&` then both conditions would need to be true. +You can also test multiple conditions with an `if` statement. In this example we want to make sure that the user is neither the admin user nor the root user to ensure the script is incapable of causing too much damage. We'll use the `or` operator in this example, noted by `||`. This means that either of the conditions needs to be true. If we used the `and` operator of `&&` then both conditions would need to be true. ```bash #!/bin/bash @@ -89,13 +89,29 @@ read -p "Enter your username? " username # Check if the username provided is the admin -if [[ "${username}" != "${admin}" ]] || [[ $EUID != 0 ]] ; then +if [[ "${username}" != "${admin}" ]] && [[ $EUID != 0 ]] ; then echo "You are not the admin or root user, but please be safe!" else echo "You are the admin user! This could be very destructive!" fi ``` +If you have multiple conditions and scenarios, then can use `elif` statement with `if` and `else` statements. + +```bash +#!/bin/bash + +read -p "Enter a number: " num + +if [[ $num -gt 0 ]] ; then + echo "The number is positive" +elif [[ $num -lt 0 ]] ; then + echo "The number is negative" +else + echo "The number is 0" +fi +``` + ## Switch case statements As in other programming languages, you can use a `case` statement to simplify complex conditionals when there are multiple different choices. So rather than using a few `if`, and `if-else` statements, you could use a single `case` statement. @@ -122,7 +138,7 @@ esac A quick rundown of the structure: * All `case` statements start with the `case` keyword. -* On the same like as the `case` keyword, you need to specify a variable or an expression followed by the `in` keyword. +* On the same line as the `case` keyword, you need to specify a variable or an expression followed by the `in` keyword. * After that, you have your `case` patterns, where you need to use `)` to identify the end of the pattern. * You can specify multiple patterns divided by a pipe: `|`. * After the pattern, you specify the commands that you would like to be executed in case that the pattern matches the variable or the expression that you've specified. @@ -132,29 +148,29 @@ A quick rundown of the structure: Here is an example of a Bash `case` statement: -``` +```bash #!/bin/bash -echo -n "Enter the name of a car brand: " -read car +read -p "Enter the name of your car brand: " car case $car in Tesla) - echo -n "${car}'s factory in the USA." + echo -n "${car}'s car factory is in the USA." ;; BMW | Mercedes | Audi | Porsche) - echo -n "${car}'s factory in Germany." + echo -n "${car}'s car factory is in Germany." ;; - Toyoda | Mazda | Mitsubishi | Subaru) - echo -n "${car}'s factory in Japan." + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "${car}'s car factory is in Japan." ;; *) - echo -n "${car} is an unknown car brand." + echo -n "${car} is an unknown car brand" ;; + esac ``` diff --git a/ebook/en/content/011-bash-loops.md b/ebook/en/content/011-bash-loops.md index 0b0bba0..bba9fc6 100644 --- a/ebook/en/content/011-bash-loops.md +++ b/ebook/en/content/011-bash-loops.md @@ -29,12 +29,12 @@ done A quick rundown of the example: * First, we specify a list of users and store the value in a variable called `$users`. -* After that, we start our `for` loop with the `for` keyword +* After that, we start our `for` loop with the `for` keyword. * Then we define a new variable which would represent each item from the list that we give. In our case, we define a variable called `user`, which would represent each user from the `$users` variable. -* Then we specify the `in` keyword followed by our list that we will loop through -* On the next line, we use the `do` keyword, which indicates what we will do for each iteration of the loop -* Then we specify the commands that we want to run -* Finally, we close the loop with the `done` keyword +* Then we specify the `in` keyword followed by our list that we will loop through. +* On the next line, we use the `do` keyword, which indicates what we will do for each iteration of the loop. +* Then we specify the commands that we want to run. +* Finally, we close the loop with the `done` keyword. You can also use `for` to process a series of numbers. For example here is one way to loop through from 1 to 10: @@ -54,7 +54,7 @@ The structure of a while loop is quite similar to the `for` loop: ```bash while [ your_condition ] do - your_conditions + your_commands done ``` @@ -98,7 +98,7 @@ The difference between `until` and `while` loops is that the `until` loop will r Structure: ```bash -until [ your_condition ] +until [[ your_condition ]] do your_commands done @@ -110,7 +110,7 @@ Example: #!/bin/bash count=1 -until [ $count -gt 10 ] +until [[ $count -gt 10 ]] do echo $count ((count++)) @@ -121,4 +121,77 @@ done As with other languages, you can use `continue` and `break` with your bash scripts as well: * `continue` tells your bash script to stop the current iteration of the loop and start the next iteration. + +The syntax of the continue statement is as follows: + +```bash +continue [n] +``` + +The [n] argument is optional and can be greater than or equal to 1. When [n] is given, the n-th enclosing loop is resumed. continue 1 is equivalent to continue. + +```bash +#!/bin/bash + +for i in 1 2 3 4 5 +do + if [[ $i -eq 2 ]] + then + echo "skipping number 2" + continue + fi + echo "i is equal to $i" +done +``` + +We can also use continue command in similar way to break command for controlling multiple loops. + * `break` tells your bash script to end the loop straight away. + +The syntax of the break statement takes the following form: + +```bash +break [n] +``` +[n] is an optional argument and must be greater than or equal to 1. When [n] is provided, the n-th enclosing loop is exited. break 1 is equivalent to break. + +Example: + +```bash +#!/bin/bash + +num=1 +while [[ $num -lt 10 ]] +do + if [[ $num -eq 5 ]] + then + break + fi + ((num++)) +done +echo "Loop completed" +``` + +We can also use break command with multiple loops. If we want to exit out of current working loop whether inner or outer loop, we simply use break but if we are in inner loop & want to exit out of outer loop, we use break 2. + +Example: + +```bash +#!/bin/bash + +for (( a = 1; a < 10; a++ )) +do + echo "outer loop: $a" + for (( b = 1; b < 100; b++ )) + do + if [[ $b -gt 5 ]] + then + break 2 + fi + echo "Inner loop: $b " + done +done +``` + +The bash script will begin with a=1 & will move to inner loop and when it reaches b=5, it will break the outer loop. +We can use break only instead of break 2, to break inner loop & see how it affects the output. diff --git a/ebook/en/content/012-bash-functions.md b/ebook/en/content/012-bash-functions.md index 10fae53..1154962 100644 --- a/ebook/en/content/012-bash-functions.md +++ b/ebook/en/content/012-bash-functions.md @@ -23,7 +23,7 @@ Example of a "Hello World!" function: ```bash #!/bin/bash -function hello(){ +function hello() { echo "Hello World Function!" } @@ -37,7 +37,7 @@ Passing arguments to a function work in the same way as passing arguments to a s ```bash #!/bin/bash -function hello(){ +function hello() { echo "Hello $1!" } @@ -58,7 +58,7 @@ Functions should have comments mentioning description, global variables, argumen # Returns: # 0 if successful, non-zero on error. ####################################### -function hello(){ +function hello() { echo "Hello $1!" } ``` diff --git a/ebook/en/content/014-creating-custom-bash-commands.md b/ebook/en/content/014-creating-custom-bash-commands.md index 441f4d2..1261976 100644 --- a/ebook/en/content/014-creating-custom-bash-commands.md +++ b/ebook/en/content/014-creating-custom-bash-commands.md @@ -2,7 +2,7 @@ As a developer or system administrator, you might have to spend a lot of time in your terminal. I always try to look for ways to optimize any repetitive tasks. -One way to do that is to either write short bash scripts or create custom commands also known as aliases. For example, rather than typing a really long command every time you could just create a short cut for it. +One way to do that is to either write short bash scripts or create custom commands also known as aliases. For example, rather than typing a really long command every time you could just create a shortcut for it. ## Example @@ -23,7 +23,7 @@ To avoid that, we can create an alias, so rather than typing the whole command, alias conn="netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" ``` -That way we are creating an alias called `conn` which would essentially be a 'short cut' for our long `netstat` command. Now if you run just `conn`: +That way we are creating an alias called `conn` which would essentially be a 'shortcut' for our long `netstat` command. Now if you run just `conn`: ```bash conn @@ -48,7 +48,7 @@ Now if you log out and log back in, your alias would be lost. In the next step y In order to make the change persistent, we need to add the `alias` command in our shell profile file. -By default on Ubuntu this would be the `~/.bashrc` file, for other operating systems this might be the `~/.bash_profle`. With your favorite text editor open the file: +By default on Ubuntu this would be the `~/.bashrc` file, for other operating systems this might be the `~/.bash_profile`. With your favorite text editor open the file: ```bash nano ~/.bashrc diff --git a/ebook/en/content/015-writing-your-first-bash-script.md b/ebook/en/content/015-writing-your-first-bash-script.md index dcc1d0a..5077b66 100644 --- a/ebook/en/content/015-writing-your-first-bash-script.md +++ b/ebook/en/content/015-writing-your-first-bash-script.md @@ -80,7 +80,7 @@ Quick run down of the function: * `function memory_check() {` - this is how we define the function * `echo ""` - here we just print a new line -* `echo "The current memory usage on ${server_name} is: "` - here we print all a small message and the `$server_name` variable +* `echo "The current memory usage on ${server_name} is: "` - here we print a small message and the `$server_name` variable * `}` - finally this is how we close the function Then once the function has been defined, in order to call it, just use the name of the function: @@ -177,4 +177,4 @@ all_checks Bash scripting is awesome! No matter if you are a DevOps/SysOps engineer, developer, or just a Linux enthusiast, you can use Bash scripts to combine different Linux commands and automate boring and repetitive daily tasks, so that you can focus on more productive and fun things! ->{notice} This was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) \ No newline at end of file +>{notice} This was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) diff --git a/ebook/en/content/016-creating-an-interactive-menu-in-bash.md b/ebook/en/content/016-creating-an-interactive-menu-in-bash.md index 0780fda..6666eb5 100644 --- a/ebook/en/content/016-creating-an-interactive-menu-in-bash.md +++ b/ebook/en/content/016-creating-an-interactive-menu-in-bash.md @@ -135,7 +135,7 @@ $(ColorBlue 'Choose an option:') " ### A quick rundown of the code -First we just echo out the menu optsions with some color: +First we just echo out the menu options with some color: ``` echo -ne " @@ -302,4 +302,4 @@ You will be able to choose a different option from the list and each number will You now know how to create a Bash menu and implement it in your scripts so that users could select different values! ->{notice} This content was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) \ No newline at end of file +>{notice} This content was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) diff --git a/ebook/en/content/017-executing-bash-script-on-multiple-remote-server.md b/ebook/en/content/017-executing-bash-script-on-multiple-remote-server.md index 74634b1..a4f0d47 100644 --- a/ebook/en/content/017-executing-bash-script-on-multiple-remote-server.md +++ b/ebook/en/content/017-executing-bash-script-on-multiple-remote-server.md @@ -4,7 +4,7 @@ Any command that you can run from the command line can be used in a bash script. Let's have a hypothetical scenario where you need to execute a BASH script on multiple remote servers, but you don't want to manually copy the script to each server, then again login to each server individually and only then execute the script. -Of course you could use a tool like Ansible but lets learn how to do that with Bash! +Of course you could use a tool like Ansible but let's learn how to do that with Bash! ## Prerequisites @@ -24,7 +24,7 @@ If you are new to DigitalOcean you can follow the steps on how to create a Dropl * [How to Create a Droplet from the DigitalOcean Control Panel](https://www.digitalocean.com/docs/droplets/how-to/create/) -You can also follow the steps from this video here on how to do your initial server setul: +You can also follow the steps from this video here on how to do your initial server setup: * [How to do your Initial Server Setup with Ubuntu](https://youtu.be/7NL2_4HIgKU) @@ -126,4 +126,4 @@ If you are interested in automation, I would recommend checking out the Ansible [Ansible Resources](https://www.digitalocean.com/community/tags/ansible) ->{notice} This content was initially posted on [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) \ No newline at end of file +>{notice} This content was initially posted on [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) diff --git a/ebook/en/content/018-working-with-json-in-bash-using-jq.md b/ebook/en/content/018-working-with-json-in-bash-using-jq.md index 5f057e5..8a9e521 100644 --- a/ebook/en/content/018-working-with-json-in-bash-using-jq.md +++ b/ebook/en/content/018-working-with-json-in-bash-using-jq.md @@ -1,12 +1,12 @@ # Work with JSON in BASH using jq -The `jq` command-line tool is is a lightweight and flexible command-line **JSON** processor. It is great for parsing JSON output in BASH. +The `jq` command-line tool is a lightweight and flexible command-line **JSON** processor. It is great for parsing JSON output in BASH. One of the great things about `jq` is that it is written in portable C, and it has zero runtime dependencies. All you need to do is to download a single binary or use a package manager like apt and install it with a single command. ## Planning the script -For the demo in this tutorial, I would use an external REST API that returns a simple JSON ouput called the [QuizAPI](https://quizapi.io/): +For the demo in this tutorial, I would use an external REST API that returns a simple JSON output called the [QuizAPI](https://quizapi.io/): > [https://quizapi.io/](https://quizapi.io/) @@ -92,7 +92,7 @@ After running the curl command, the output which you would get would look like t ![Raw Json output](https://imgur.com/KghOfzj.png) -This could be quite hard to read, but thanks to the jq command-line tool, all we need to do is pipe the curl command to jq and we would see a nice formated JSON output: +This could be quite hard to read, but thanks to the jq command-line tool, all we need to do is pipe the curl command to jq and we would see a nice formatted JSON output: ```bash curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq @@ -222,4 +222,4 @@ And for more information on the **QuizAPI**, you could take a look at the offici * [https://quizapi.io/docs/1.0/overview](https://quizapi.io/docs/1.0/overview) ->{notice} This content was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) \ No newline at end of file +>{notice} This content was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) diff --git a/ebook/en/content/021-how-to-send-emails-with-bash.md b/ebook/en/content/021-how-to-send-emails-with-bash.md index 9f70f27..bce8624 100644 --- a/ebook/en/content/021-how-to-send-emails-with-bash.md +++ b/ebook/en/content/021-how-to-send-emails-with-bash.md @@ -12,7 +12,7 @@ You would need the following things in order to be able to complete this tutoria * Access to an Ubuntu 18.04 server as a non-root user with sudo privileges and an active firewall installed on your server. To set these up, please refer to our [Initial Server Setup Guide for Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) -* An SMTP server along with SMTP username and password, this would also work with Gmail's SMTP server, or you could set up your own SMTP server by following the steps from this tutorial on [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16-04](How to Install and Configure Postfix as a Send-Only SMTP Server on Ubuntu 16.04) +* An SMTP server along with SMTP username and password, this would also work with Gmail's SMTP server, or you could set up your own SMTP server by following the steps from this tutorial on [How to Install and Configure Postfix as a Send-Only SMTP Server on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16-04) ## Installing SSMTP @@ -38,13 +38,13 @@ sudo apt install mailutils Now that you have `ssmtp` installed, in order to configure it to use your SMTP server when sending emails, you need to edit the SSMTP configuration file. -Using your favourite text editor opent the `/etc/ssmtp/ssmtp.conf` file: +Using your favourite text editor to open the `/etc/ssmtp/ssmtp.conf` file: ```bash sudo nano /etc/ssmtp/ssmtp.conf ``` -You need to incldue the your SMTP configuration: +You need to include your SMTP configuration: ``` root=postmaster @@ -92,4 +92,4 @@ SSMTP is a great and reliable way to implement SMTP email functionality directly For more information about SSMTP I would recommend checking the official documentation [here](https://wiki.archlinux.org/index.php/SSMTP). ->{notice} This content was initially posted on the [DigitalOcean community forum](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp). \ No newline at end of file +>{notice} This content was initially posted on the [DigitalOcean community forum](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp). diff --git a/ebook/en/content/022-bash-password-generator.md b/ebook/en/content/022-bash-password-generator.md index aeadc6a..d9d9170 100644 --- a/ebook/en/content/022-bash-password-generator.md +++ b/ebook/en/content/022-bash-password-generator.md @@ -85,7 +85,7 @@ Generate the passwords and then print it so the user can use it. # This is where the magic happens! # Generate a list of 10 strings and cut it to the desired value provided from the user -for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_lenght} | head -n 1); done +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_length} | head -n 1); done # Print the strings printf "$pass_output\n" @@ -102,13 +102,13 @@ printf "Goodbye, ${USER}\n" # Ask user for the string length clear printf "\n" -read -p "How many characters you would like the password to have? " pass_lenght +read -p "How many characters you would like the password to have? " pass_length printf "\n" # This is where the magic happens! # Generate a list of 10 strings and cut it to the desired value provided from the user -for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_lenght} | head -n 1); done +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_length} | head -n 1); done # Print the strings printf "$pass_output\n" diff --git a/ebook/en/content/023-bash-redirection.md b/ebook/en/content/023-bash-redirection.md index 82c80c4..fc4a94e 100644 --- a/ebook/en/content/023-bash-redirection.md +++ b/ebook/en/content/023-bash-redirection.md @@ -2,7 +2,7 @@ A Linux superuser must have a good knowledge of pipes and redirection in Bash. It is an essential component of the system and is often helpful in the field of Linux System Administration. -When you run a command like ``ls``, ``cat``, etc, you get some output on the terminal. If you write a wrong command, pass a wrong flag or an wrong command-line argument, you get error output on the terminal. +When you run a command like ``ls``, ``cat``, etc, you get some output on the terminal. If you write a wrong command, pass a wrong flag or a wrong command-line argument, you get error output on the terminal. In both the cases, you are given some text. It may seem like "just text" to you, but the system treats this text differently. This identifier is known as a File Descriptor (fd). In Linux, there are 3 File Descriptors, **STDIN** (0); **STDOUT** (1) and **STDERR** (2). @@ -13,9 +13,9 @@ In Linux, there are 3 File Descriptors, **STDIN** (0); **STDOUT** (1) and **STDE # Difference between Pipes and Redirections -Both *pipes* and *redidertions* redirect streams `(file descriptor)` of process being executed. The main diffrence is that *redirections* deal with `files stream`, sending the output stream to a file or sending the content of a given file to the input stream of the process. +Both *pipes* and *redirections* redirect streams `(file descriptor)` of process being executed. The main difference is that *redirections* deal with `files stream`, sending the output stream to a file or sending the content of a given file to the input stream of the process. -On the otherhand a pipe connects two commands by sending the output stream of the first one to the input stream of the second one. without any redidertions specified. +On the other hand a pipe connects two commands by sending the output stream of the first one to the input stream of the second one. without any redirections specified. # Redirection in Bash @@ -57,8 +57,8 @@ Example: ``` echo "Hello World!" > file.txt ``` -The following command will not print "Hello World" on the terminal screen, it will instead create a file called ``file.txt`` and will write the "Hello World" string to it. -This can be verified by runnning the ``cat`` command on the ``file.txt`` file. +The above command will not print "Hello World" on the terminal screen, it will instead create a file called ``file.txt`` and will write the "Hello World" string to it. +This can be verified by running the ``cat`` command on the ``file.txt`` file. ``` cat file.txt ``` @@ -103,7 +103,7 @@ echo "Hello World!" 1> file.txt ## STDERR (Standard Error) -The error text on the terminal screen is printed via the **STDERR** of the the command. For example: +The error text on the terminal screen is printed via the **STDERR** of the command. For example: ``` ls --hello ``` @@ -160,7 +160,7 @@ Syntax: You can also build arbitrary chains of commands by piping them together to achieve a powerful result. -This examble create a listing of every user which owns a file in a given directory as well as how many files and directories they own: +This example creates a listing of every user which owns a file in a given directory as well as how many files and directories they own: ``` ls -l /projects/bash_scripts | tail -n +2 | sed 's/\s\s*/ /g' | cut -d ' ' -f 3 | sort | uniq -c ``` @@ -172,6 +172,50 @@ Output: 18 ryan ``` +# HereDocument + +The symbol `<<` can be used to create a temporary file [heredoc] and redirect from it at the command line. +``` +COMMAND << EOF + ContentOfDocument + ... + ... +EOF +``` +Note here that `EOF` represents the delimiter (end of file) of the heredoc. In fact, we can use any alphanumeric word in its place to signify the start and the end of the file. For instance, this is a valid heredoc: +``` +cat << randomword1 + This script will print these lines on the terminal. + Note that cat can read from standard input. Using this heredoc, we can + create a temporary file with these lines as it's content and pipe that + into cat. +randomword1 +``` + +Effectively it will appear as if the contents of the heredoc are piped into the command. This can make the script very clean if multiple lines need to be piped into a program. + +Further, we can attach more pipes as shown: +``` +cat << randomword1 | wc + This script will print these lines on the terminal. + Note that cat can read from standard input. Using this heredoc, we can + create a temporary file with these lines as it's content and pipe that + into cat. +randomword1 +``` + +Also, pre-defined variables can be used inside the heredocs. + +# HereString + +Herestrings are quite similar to heredocs but use `<<<`. These are used for single line strings that have to be piped into some program. This looks cleaner that heredocs as we don't have to specify the delimiter. + +``` +wc <<<"this is an easy way of passing strings to the stdin of a program (here wc)" +``` + +Just like heredocs, herestrings can contain variables. + ## Summary |**Operator** |**Description** | |:---|:---| @@ -180,3 +224,5 @@ Output: |`<`|`Read input from a file`| |`2>`|`Redirect error messages`| |`\|`|`Send the output from one program as input to another program`| +|`<<`|`Pipe multiple lines into a program cleanly`| +|`<<<`|`Pipe a single line into a program cleanly`| diff --git a/ebook/en/content/024-automating-wordpress-lamp-with-bash.md b/ebook/en/content/024-automating-wordpress-lamp-with-bash.md new file mode 100644 index 0000000..d7ca9eb --- /dev/null +++ b/ebook/en/content/024-automating-wordpress-lamp-with-bash.md @@ -0,0 +1,336 @@ +# Automatic WordPress on LAMP installation with BASH + +Here is an example of a full LAMP and WordPress installation that works on any Debian-based machine. + +# Prerequisites + +- A Debian-based machine (Ubuntu, Debian, Linux Mint, etc.) + +# Planning the functionality + +Let's start again by going over the main functionality of the script: + +**Lamp Installation** + +* Update the package manager +* Install a firewall (ufw) +* Allow SSH, HTTP and HTTPS traffic +* Install Apache2 +* Install & Configure MariaDB +* Install PHP and required plugins +* Enable all required Apache2 mods + +**Apache Virtual Host Setup** + +* Create a directory in `/var/www` +* Configure permissions to the directory +* Create the `$domain` file under `/etc/apache2/sites-available` and append the required Virtualhost content +* Enable the site +* Restart Apache2 + +**SSL Config** + +* Generate the OpenSSL certificate +* Append the SSL certificate to the `ssl-params.conf` file +* Append the SSL config to the Virtualhost file +* Enable SSL +* Reload Apache2 + +**Database Config** + +* Create a database +* Create a user +* Flush Privileges + +**WordPress Config** + +* Install required WordPress PHP plugins +* Install WordPress +* Append the required information to `wp-config.php` file + +Without further ado, let's start writing the script. + +# The script + +We start by setting our variables and asking the user to input their domain: + +```bash +echo 'Please enter your domain of preference without www:' +read DOMAIN +echo "Please enter your Database username:" +read DBUSERNAME +echo "Please enter your Database password:" +read DBPASSWORD +echo "Please enter your Database name:" +read DBNAME + +ip=`hostname -I | cut -f1 -d' '` +``` + +We are now ready to start writing our functions. Start by creating the `lamp_install()` function. Inside of it, we are going to update the system, install ufw, allow SSH, HTTP and HTTPS traffic, install Apache2, install MariaDB and PHP. We are also going to enable all required Apache2 mods. + +```bash +lamp_install () { + apt update -y + apt install ufw + ufw enable + ufw allow OpenSSH + ufw allow in "WWW Full" + + apt install apache2 -y + apt install mariadb-server + mysql_secure_installation -y + apt install php libapache2-mod-php php-mysql -y + sed -i "2d" /etc/apache2/mods-enabled/dir.conf + sed -i "2i\\\tDirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm" /etc/apache2/mods-enabled/dir.conf + systemctl reload apache2 + +} +``` + +Next, we are going to create the `apache_virtualhost_setup()` function. Inside of it, we are going to create a directory in `/var/www`, configure permissions to the directory, create the `$domain` file under `/etc/apache2/sites-available` and append the required Virtualhost content, enable the site and restart Apache2. + +```bash +apache_virtual_host_setup () { + mkdir /var/www/$DOMAIN + chown -R $USER:$USER /var/www/$DOMAIN + + echo "" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerName $DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerAlias www.$DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerAdmin webmaster@localhost" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tDocumentRoot /var/www/$DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e '\tErrorLog ${APACHE_LOG_DIR}/error.log' >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e '\tCustomLog ${APACHE_LOG_DIR}/access.log combined' >> /etc/apache2/sites-available/$DOMAIN.conf + echo "" >> /etc/apache2/sites-available/$DOMAIN.conf + a2ensite $DOMAIN + a2dissite 000-default + systemctl reload apache2 + +} +``` + +Next, we are going to create the `ssl_config()` function. Inside of it, we are going to generate the OpenSSL certificate, append the SSL certificate to the `ssl-params.conf` file, append the SSL config to the Virtualhost file, enable SSL and reload Apache2. + +```bash +ssl_config () { + openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt + + echo "SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLHonorCipherOrder On" >> /etc/apache2/conf-available/ssl-params.conf + echo "Header always set X-Frame-Options DENY" >> /etc/apache2/conf-available/ssl-params.conf + echo "Header always set X-Content-Type-Options nosniff" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLCompression off" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLUseStapling on" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLStaplingCache \"shmcb:logs/stapling-cache(150000)\"" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLSessionTickets Off" >> /etc/apache2/conf-available/ssl-params.conf + + cp /etc/apache2/sites-available/default-ssl.conf /etc/apache2/sites-available/default-ssl.conf.bak + sed -i "s/var\/www\/html/var\/www\/$DOMAIN/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "s/etc\/ssl\/certs\/ssl-cert-snakeoil.pem/etc\/ssl\/certs\/apache-selfsigned.crt/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "s/etc\/ssl\/private\/ssl-cert-snakeoil.key/etc\/ssl\/private\/apache-selfsigned.key/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "4i\\\t\tServerName $ip" /etc/apache2/sites-available/default-ssl.conf + sed -i "22i\\\tRedirect permanent \"/\" \"https://$ip/\"" /etc/apache2/sites-available/000-default.conf + a2enmod ssl + a2enmod headers + a2ensite default-ssl + a2enconf ssl-params + systemctl reload apache2 +} +``` + +Next, we are going to create the `db_setup()` function. Inside of it, we are going to create the database, create the user and grant all privileges to the user. + +```bash +db_config () { + mysql -e "CREATE DATABASE $DBNAME;" + mysql -e "GRANT ALL ON $DBNAME.* TO '$DBUSERNAME'@'localhost' IDENTIFIED BY '$DBPASSWORD' WITH GRANT OPTION;" + mysql -e "FLUSH PRIVILEGES;" +} +``` + +Next, we are going to create the `wordpress_config()` function. Inside of it, we are going to download the latest version of WordPress, extract it to the `/var/www/$DOMAIN` directory, create the `wp-config.php` file and append the required content to it. + +```bash +wordpress_config () { + db_config + + + apt install php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip -y + systemctl restart apache2 + sed -i "8i\\\t" /etc/apache2/sites-available/$DOMAIN.conf + sed -i "9i\\\t\tAllowOverride All" /etc/apache2/sites-available/$DOMAIN.conf + sed -i "10i\\\t" /etc/apache2/sites-available/$DOMAIN.conf + + a2enmod rewrite + systemctl restart apache2 + + apt install curl + cd /tmp + curl -O https://wordpress.org/latest.tar.gz + tar xzvf latest.tar.gz + touch /tmp/wordpress/.htaccess + cp /tmp/wordpress/wp-config-sample.php /tmp/wordpress/wp-config.php + mkdir /tmp/wordpress/wp-content/upgrade + cp -a /tmp/wordpress/. /var/www/$DOMAIN + chown -R www-data:www-data /var/www/$DOMAIN + find /var/www/$DOMAIN/ -type d -exec chmod 750 {} \; + find /var/www/$DOMAIN/ -type f -exec chmod 640 {} \; + curl -s https://api.wordpress.org/secret-key/1.1/salt/ >> /var/www/$DOMAIN/wp-config.php + echo "define('FS_METHOD', 'direct');" >> /var/www/$DOMAIN/wp-config.php + sed -i "51,58d" /var/www/$DOMAIN/wp-config.php + sed -i "s/database_name_here/$DBNAME/1" /var/www/$DOMAIN/wp-config.php + sed -i "s/username_here/$DBUSERNAME/1" /var/www/$DOMAIN/wp-config.php + sed -i "s/password_here/$DBPASSWORD/1" /var/www/$DOMAIN/wp-config.php +} +``` + +And finally, we are going to create the `execute()` function. Inside of it, we are going to call all the functions we created above. + +```bash +execute () { + lamp_install + apache_virtual_host_setup + ssl_config + wordpress_config +} +``` + +With this, you have the script ready and you are ready to run it. And if you need the full script, you can find it in the next section. + +# The full script + +```bash +#!/bin/bash + +echo 'Please enter your domain of preference without www:' +read DOMAIN +echo "Please enter your Database username:" +read DBUSERNAME +echo "Please enter your Database password:" +read DBPASSWORD +echo "Please enter your Database name:" +read DBNAME + +ip=`hostname -I | cut -f1 -d' '` + +lamp_install () { + apt update -y + apt install ufw + ufw enable + ufw allow OpenSSH + ufw allow in "WWW Full" + + apt install apache2 -y + apt install mariadb-server + mysql_secure_installation -y + apt install php libapache2-mod-php php-mysql -y + sed -i "2d" /etc/apache2/mods-enabled/dir.conf + sed -i "2i\\\tDirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm" /etc/apache2/mods-enabled/dir.conf + systemctl reload apache2 + +} + +apache_virtual_host_setup () { + mkdir /var/www/$DOMAIN + chown -R $USER:$USER /var/www/$DOMAIN + + echo "" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerName $DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerAlias www.$DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tServerAdmin webmaster@localhost" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e "\tDocumentRoot /var/www/$DOMAIN" >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e '\tErrorLog ${APACHE_LOG_DIR}/error.log' >> /etc/apache2/sites-available/$DOMAIN.conf + echo -e '\tCustomLog ${APACHE_LOG_DIR}/access.log combined' >> /etc/apache2/sites-available/$DOMAIN.conf + echo "" >> /etc/apache2/sites-available/$DOMAIN.conf + a2ensite $DOMAIN + a2dissite 000-default + systemctl reload apache2 + +} + + +ssl_config () { + openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/apache-selfsigned.key -out /etc/ssl/certs/apache-selfsigned.crt + + echo "SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLHonorCipherOrder On" >> /etc/apache2/conf-available/ssl-params.conf + echo "Header always set X-Frame-Options DENY" >> /etc/apache2/conf-available/ssl-params.conf + echo "Header always set X-Content-Type-Options nosniff" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLCompression off" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLUseStapling on" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLStaplingCache \"shmcb:logs/stapling-cache(150000)\"" >> /etc/apache2/conf-available/ssl-params.conf + echo "SSLSessionTickets Off" >> /etc/apache2/conf-available/ssl-params.conf + + cp /etc/apache2/sites-available/default-ssl.conf /etc/apache2/sites-available/default-ssl.conf.bak + sed -i "s/var\/www\/html/var\/www\/$DOMAIN/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "s/etc\/ssl\/certs\/ssl-cert-snakeoil.pem/etc\/ssl\/certs\/apache-selfsigned.crt/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "s/etc\/ssl\/private\/ssl-cert-snakeoil.key/etc\/ssl\/private\/apache-selfsigned.key/1" /etc/apache2/sites-available/default-ssl.conf + sed -i "4i\\\t\tServerName $ip" /etc/apache2/sites-available/default-ssl.conf + sed -i "22i\\\tRedirect permanent \"/\" \"https://$ip/\"" /etc/apache2/sites-available/000-default.conf + a2enmod ssl + a2enmod headers + a2ensite default-ssl + a2enconf ssl-params + systemctl reload apache2 +} + +db_config () { + mysql -e "CREATE DATABASE $DBNAME;" + mysql -e "GRANT ALL ON $DBNAME.* TO '$DBUSERNAME'@'localhost' IDENTIFIED BY '$DBPASSWORD' WITH GRANT OPTION;" + mysql -e "FLUSH PRIVILEGES;" +} + +wordpress_config () { + db_config + + + apt install php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip -y + systemctl restart apache2 + sed -i "8i\\\t" /etc/apache2/sites-available/$DOMAIN.conf + sed -i "9i\\\t\tAllowOverride All" /etc/apache2/sites-available/$DOMAIN.conf + sed -i "10i\\\t" /etc/apache2/sites-available/$DOMAIN.conf + + a2enmod rewrite + systemctl restart apache2 + + apt install curl + cd /tmp + curl -O https://wordpress.org/latest.tar.gz + tar xzvf latest.tar.gz + touch /tmp/wordpress/.htaccess + cp /tmp/wordpress/wp-config-sample.php /tmp/wordpress/wp-config.php + mkdir /tmp/wordpress/wp-content/upgrade + cp -a /tmp/wordpress/. /var/www/$DOMAIN + chown -R www-data:www-data /var/www/$DOMAIN + find /var/www/$DOMAIN/ -type d -exec chmod 750 {} \; + find /var/www/$DOMAIN/ -type f -exec chmod 640 {} \; + curl -s https://api.wordpress.org/secret-key/1.1/salt/ >> /var/www/$DOMAIN/wp-config.php + echo "define('FS_METHOD', 'direct');" >> /var/www/$DOMAIN/wp-config.php + sed -i "51,58d" /var/www/$DOMAIN/wp-config.php + sed -i "s/database_name_here/$DBNAME/1" /var/www/$DOMAIN/wp-config.php + sed -i "s/username_here/$DBUSERNAME/1" /var/www/$DOMAIN/wp-config.php + sed -i "s/password_here/$DBPASSWORD/1" /var/www/$DOMAIN/wp-config.php +} + +execute () { + lamp_install + apache_virtual_host_setup + ssl_config + wordpress_config +} +``` + +## Summary + +The script does the following: + + * Install LAMP + * Create a virtual host + * Configure SSL + * Install WordPress + * Configure WordPress + +With this being said, I hope you enjoyed this example. If you have any questions, please feel free to ask me directly at [@denctl](https://twitter.com/denctl). diff --git a/ebook/en/content/100-bash-wrap-up.md b/ebook/en/content/100-bash-wrap-up.md index 9daa63f..bf808d8 100644 --- a/ebook/en/content/100-bash-wrap-up.md +++ b/ebook/en/content/100-bash-wrap-up.md @@ -10,6 +10,6 @@ In this introduction to Bash scripting book, we just covered the basics, but you As a next step try writing your own script and share it with the world! This is the best way to learn any new programming or scripting language! -In case that this book enspired you to write some cool Bash scripts, make sure to tweet about it and tag [@bobbyiliev_](https://twitter.com) so that we could check it out! +In case that this book inspired you to write some cool Bash scripts, make sure to tweet about it and tag [@bobbyiliev_](https://twitter.com) so that we could check it out! -Congrats again on completing this book! \ No newline at end of file +Congrats again on completing this book! diff --git a/ebook/en/epub.yml b/ebook/en/epub.yml new file mode 100644 index 0000000..c18e03d --- /dev/null +++ b/ebook/en/epub.yml @@ -0,0 +1,14 @@ +--- +# Generate an ePub by running: +# pandoc content/*.md epub.yml -o export/introduction-to-bash-scripting.epub +title: Introduction to Bash Scripting +author: Bobby Iliev +cover-image: ./ebook/en/assets/cover.jpg +rights: MIT License +lang: en-US +tags: [bash, Unix, Linux] + +# Filter preferences: +# - pandoc-crossref +linkReferences: true +--- \ No newline at end of file diff --git a/ebook/en/export/introduction-to-bash-scripting-dark.pdf b/ebook/en/export/introduction-to-bash-scripting-dark.pdf index c5d2268..239a9c3 100644 Binary files a/ebook/en/export/introduction-to-bash-scripting-dark.pdf and b/ebook/en/export/introduction-to-bash-scripting-dark.pdf differ diff --git a/ebook/en/export/introduction-to-bash-scripting-light.pdf b/ebook/en/export/introduction-to-bash-scripting-light.pdf index a370f2e..fdc197d 100644 Binary files a/ebook/en/export/introduction-to-bash-scripting-light.pdf and b/ebook/en/export/introduction-to-bash-scripting-light.pdf differ diff --git a/ebook/en/export/introduction-to-bash-scripting.epub b/ebook/en/export/introduction-to-bash-scripting.epub new file mode 100644 index 0000000..0b99161 Binary files /dev/null and b/ebook/en/export/introduction-to-bash-scripting.epub differ diff --git a/ebook/en/export/sample-.introduction-to-bash-scripting-dark.pdf b/ebook/en/export/sample-.introduction-to-bash-scripting-dark.pdf index 4c0cb8a..f7bb909 100644 Binary files a/ebook/en/export/sample-.introduction-to-bash-scripting-dark.pdf and b/ebook/en/export/sample-.introduction-to-bash-scripting-dark.pdf differ diff --git a/ebook/en/export/sample-.introduction-to-bash-scripting-light.pdf b/ebook/en/export/sample-.introduction-to-bash-scripting-light.pdf index 63856c3..a52a6f3 100644 Binary files a/ebook/en/export/sample-.introduction-to-bash-scripting-light.pdf and b/ebook/en/export/sample-.introduction-to-bash-scripting-light.pdf differ diff --git a/ebook/es/assets/cover.jpg b/ebook/es/assets/cover.jpg new file mode 100644 index 0000000..d6db238 Binary files /dev/null and b/ebook/es/assets/cover.jpg differ diff --git a/ebook/es/assets/cover.jpg-bak b/ebook/es/assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/es/assets/cover.jpg-bak differ diff --git a/ebook/es/assets/theme-dark.html b/ebook/es/assets/theme-dark.html new file mode 100644 index 0000000..6f12e6d --- /dev/null +++ b/ebook/es/assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/es/assets/theme-light.html b/ebook/es/assets/theme-light.html new file mode 100644 index 0000000..561b80c --- /dev/null +++ b/ebook/es/assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/es/content/000-about-the-author.md b/ebook/es/content/000-about-the-author.md new file mode 100644 index 0000000..3d6bbc6 --- /dev/null +++ b/ebook/es/content/000-about-the-author.md @@ -0,0 +1,87 @@ +# Acerca del libro + +* **Esta versión fue publicada el 1 de febrero de 2021** + +Esta es una guía de introducción de código abierto a los scripts de Bash que le ayudará a aprender los fundamentos de los scripts de Bash y comenzar a escribir scripts de Bash impresionantes que le facilitará a automatizar sus tareas diarias de SysOps, DevOps y desarrollador. No importa si es un ingeniero de DevOps/SysOps, desarrollador, o simplemente un entusiasta de Linux, puede usar scripts Bash para combinar diferentes comandos de Linux y automatizar tareas diarias tediosas y repetitivas para que pueda centrarte en cosas más productivas y divertidas. + +La guía es adecuada para cualquier persona que trabaje como desarrollador, administrador de sistemas o ingeniero DevOps y quiera aprender los fundamentos de los scripts de Bash. + +Los primeros 13 capítulos se centrarán exclusivamente en la obtención de algunos fundamentos sólidos de scripting Bash, luego el resto de los capítulos le dará algunos ejemplos y scripts de la vida real. + +## Acerca del autor + +Mi nombre es Bobby Iliev, y he estado trabajando como ingeniero de DevOps de Linux desde 2014. Soy un ávido amante de Linux y partidario de la filosofía del movimiento de código abierto. Siempre estoy haciendo aquello que no puedo hacer para poder aprender a hacerlo, y creo en compartir el conocimiento. + +Creo que es esencial mantenerse siempre profesional y rodearse de buena gente, trabajar duro y ser amable con todo el mundo. Hay que rendir siempre a un nivel superior al de los demás. Esa es la marca de un verdadero profesional. + +Para más información, visite mi blog en [https://bobbyiliev.com](https://bobbyiliev.com), sígame en Twitter [@bobbyiliev_](https://twitter.com/bobbyiliev_) y [YouTube](https://www.youtube.com/channel/UCQWmdHTeAO0UvaNqve9udRw). + +## Patrocinadores + +¡Este libro es posible gracias a estas fantásticas empresas! + +### Materialize + +La base de datos de streaming para las Analytics en tiempo real. + +[Materialize](https://materialize.com/) es una base de datos reactiva que ofrece actualizaciones de vistas incrementales. Materialize ayuda a los desarrolladores a construir fácilmente con datos en streaming utilizando SQL estándar. + +### DigitalOcean + +DigitalOcean es una plataforma de servicios en la nube que ofrece la simplicidad que los desarrolladores adoran y las empresas confían para ejecutar aplicaciones de producción a escala. + +Proporciona soluciones de computación, almacenamiento y redes altamente disponibles, seguras y escalables que ayudan a los desarrolladores a crear un gran software más rápido. + +Fundada en 2012 y con oficinas en Nueva York y Cambridge, MA, DigitalOcean ofrece precios transparentes y asequibles, una interfaz de usuario elegante y una de las mayores bibliotecas de recursos de código abierto disponibles. + +Para más información, visite [https://www.digitalocean.com](https://www.digitalocean.com) o siga a [@digitalocean](https://twitter.com/digitalocean) en Twitter. + +Si es nuevo en DigitalOcean, puede obtener un crédito gratuito de 100 dólares y crear sus propios servidores a través de este enlace de referido aquí: + +[Crédito gratuito de 100 dólares para DigitalOcean](https://m.do.co/c/2a9bba940f39) + +### DevDojo + +El DevDojo es un recurso para aprender todo lo relacionado con el desarrollo y el diseño web. Aprenda en su hora de almuerzo o levántese y disfrute de una taza de café con nosotros para aprender algo nuevo. + +Únase a esta comunidad de desarrolladores y podremos aprender juntos, construir juntos y crecer juntos. + +[Únase a DevDojo](https://devdojo.com?ref=bobbyiliev) + +Para más información, visite [https://www.devdojo.com](https://www.devdojo.com?ref=bobbyiliev) o siga a [@thedevdojo](https://twitter.com/thedevdojo) en Twitter. + +## Herramienta de generación de PDFs para libros electrónicos + +Este ebook fue generado por [Ibis](https://github.com/themsaid/ibis/) desarrollado por [Mohamed Said](https://github.com/themsaid). + +Ibis es una herramienta PHP que te ayuda a escribir eBooks en markdown. + +## Portada del libro + +La portada de este libro electrónico fue creada con [Canva.com](https://www.canva.com/join/determined-cork-learn). + +Si alguna vez necesita crear un gráfico, un póster, una invitación, un logotipo, una presentación, o cualquier cosa que se vea bien, dele una oportunidad a Canva. + +## Licencia + +MIT License + +Copyright (c) 2020 Bobby Iliev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/ebook/es/content/001-introduction-to-bash.md b/ebook/es/content/001-introduction-to-bash.md new file mode 100644 index 0000000..751d6a2 --- /dev/null +++ b/ebook/es/content/001-introduction-to-bash.md @@ -0,0 +1,10 @@ +# Introducción al scripting de Bash + +¡Bienvenido a esta guía de entrenamiento de los fundamentos de Bash! En este **curso intensivo de Bash**, aprenderá los **aspectos básicos de Bash** para que pueda empezar a escribir sus propios scripts de Bash y automatizar sus tareas diarias. + +Bash es un lenguaje de comandos y consola de Unix. Está ampliamente disponible en varios sistemas operativos, y también es el intérprete de comandos por defecto en la mayoría de los sistemas Linux. + +Bash significa _Bourne-Again SHell_. Al igual que otros shells, puede usar Bash de forma interactiva directamente en tu terminal, y también, puede usar Bash como cualquier otro lenguaje de programación para escribir scripts. Este libro le ayudará a aprender los fundamentos de la escritura de scripts en Bash, incluyendo las variables de Bash, entrada del usuario, comentarios, argumentos, arreglos, expresiones condicionales, condicionales, bucles, funciones, depuración y pruebas. + +Para escribir scripts Bash, solo necesita un terminal UNIX y un editor de texto como Sublime Text, VS Code, o un editor basado en terminal como vim o nano. + diff --git a/ebook/es/content/002-bash-structure.md b/ebook/es/content/002-bash-structure.md new file mode 100644 index 0000000..87296de --- /dev/null +++ b/ebook/es/content/002-bash-structure.md @@ -0,0 +1,25 @@ +# Estructura de Bash + +Comencemos creando un nuevo archivo con extensión `.sh`. Como ejemplo, podríamos crear un archivo llamado `devdojo.sh`. + +Para crear ese archivo, puede usar el comando `touch`: + +```bash +touch devdojo.sh +``` + +O en vez de eso, puede usar su editor de texto: + +```bash +nano devdojo.sh +``` + +Para ejecutar/correr un archivo de script bash con el intérprete de shell bash, la primera línea de un archivo de script debe indicar la ruta absoluta al ejecutable bash: + +```bash +#!/bin/bash +``` + +Esto también se llama [Shebang](https://es.wikipedia.org/wiki/Shebang). + +Todo lo que hace el shebang es indicar al sistema operativo que ejecute el script con el ejecutable `/bin/bash`. diff --git a/ebook/es/content/003-bash-hello-world.md b/ebook/es/content/003-bash-hello-world.md new file mode 100644 index 0000000..6d90721 --- /dev/null +++ b/ebook/es/content/003-bash-hello-world.md @@ -0,0 +1,41 @@ +# Hola Mundo con Bash + +Una vez que tenemos nuestro archivo `devdojo.sh` creado y hemos especificado el shebang de bash en la primera línea, estamos listos para crear nuestro primer script bash: `Hola Mundo`. + +Para ello, abra de nuevo el archivo `devdojo.sh` y añada lo siguiente después de la línea `#!/bin/bash`: + +```bash +#!/bin/bash + +echo "¡Hola Mundo!" +``` + +Guarde el archivo y salga. + +Después haga que el script sea ejecutable con el siguiente comando en la consola + +```bash +chmod +x devdojo.sh +``` + +Después ejecute el archivo: + +```bash +./devdojo.sh +``` + +Verá un mensaje de "¡Hola Mundo!" en la pantalla. + +Otra forma de ejecutar el script sería + +```bash +bash devdojo.sh +``` + +Como bash se puede utilizar de forma interactiva, podría ejecutar el siguiente comando directamente en su terminal y obtendría el mismo resultado: + +```bash +echo "¡Hola Mundo!" +``` + +Armar un script es útil cuando tiene que combinar varios comandos. diff --git a/ebook/es/content/004-bash-variables.md b/ebook/es/content/004-bash-variables.md new file mode 100644 index 0000000..3c50340 --- /dev/null +++ b/ebook/es/content/004-bash-variables.md @@ -0,0 +1,86 @@ +# Variables en Bash + +Como en cualquier otro lenguaje de programación, también puede usar variables en Bash scripting. Sin embargo, no hay tipos de datos, y una variable en Bash puede contener tanto números como caracteres. + +Para asignar un valor a una variable, todo lo que necesita hacer es usar el signo `=`: + +```bash +nombre="DevDojo" +``` + +>{notice} como nota importante, no puede haber espacios antes y después del signo `=`. + +Después de eso, para acceder a la variable, debe utilizar el `$` y la referencia como se muestra debajo: + +```bash +echo $nombre +``` + +Envolver el nombre de la variable entre llaves no es obligatorio, pero se considera una buena práctica, y le aconsejo que las use siempre que pueda: + +```bash +echo ${nombre} +``` + +El código anterior daría como resultado `DevDojo` ya que este es el valor de nuestra variable `nombre`. + +A continuación, vamos a actualizar nuestro script `devdojo.sh` e incluir una variable en él. + +De nuevo, puede abrir el archivo `devdojo.sh` con su editor de texto favorito, yo estoy usando nano aquí para abrir el archivo: + +```bash +nano devdojo.sh +``` + +Añadiendo nuestra variable `nombre` aquí en el archivo, con un mensaje de bienvenida. Nuestro archivo ahora se ve así: + +```bash +#!/bin/bash + +nombre="DevDojo" + +echo "Hola $nombre" +``` + +Guárdelo y ejecute el archivo con el siguiente comando: + +```bash +./devdojo.sh +``` + +Verá la siguiente salida en su pantalla: + +```bash +Hola DevDojo +``` + +Aquí está un resumen del script escrito en el archivo: + +* `#!/bin/bash` - Al principio, especificamos nuestro shebang. +* `nombre=DevDojo` - Luego, definimos una variable llamada `nombre` y le asignamos un valor. +* `echo "Hola $nombre"` - Finalmente, mostramos el contenido de la variable en la pantalla como un mensaje de bienvenida usando `echo`. + +También puede añadir múltiples variables en el archivo como se muestra debajo: + +```bash +#!/bin/bash + +nombre="DevDojo" +saludo="Hola" + +echo "$saludo $nombre" +``` + +Guarde el archivo y ejecútelo de nuevo: + +```bash +./devdojo.sh +``` + +Verá la siguiente salida en su pantalla: + +```bash +Hola DevDojo +``` + +Tenga en cuenta que no necesariamente tiene que añadir punto y coma `;` al final de cada línea. Funciona de ambas maneras, un poco como otros lenguajes de programación como JavaScript. diff --git a/ebook/es/content/005-bash-user-input.md b/ebook/es/content/005-bash-user-input.md new file mode 100644 index 0000000..17a5f5e --- /dev/null +++ b/ebook/es/content/005-bash-user-input.md @@ -0,0 +1,54 @@ +# Entrada de Usuario en Bash + +Con el script anterior, definimos una variable, y mostramos el valor de la variable en la pantalla con el `echo $nombre`. + +Ahora vamos a seguir adelante y pedir al usuario que ingrese el dato en su lugar. Para hacerlo de nuevo, abra el archivo con su editor de texto favorito y actualice el script como sigue: + +```bash +#!/bin/bash + +echo "¿Cuál es su nombre?" +read nombre + +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +Lo anterior pedirá al usuario su entrada y luego almacenará esa entrada como una cadena/texto en una variable. + +Luego podemos utilizar la variable e imprimir un mensaje de respuesta. + +La salida del script anterior sería: + +* Primero ejecute el script: + +```bash +./devdojo.sh +``` + +* Luego, se le pedirá que introduzca su nombre: + +``` +¿Cuál es su nombre? +Bobby +``` + +* Una vez que haya introducido su nombre, simplemente pulse enter, y obtendrá el siguiente resultado: + +``` +Hola Bobby +¡Bienvenido a DevDojo! +``` + +Para reducir el código, podríamos cambiar la primera sentencia `echo` por el comando `read -p`, el comando `read` usado con la bandera `-p` imprimirá un mensaje antes de pedir al usuario su entrada: + +```bash +#!/bin/bash + +read -p "¿Cuál es su nombre? " nombre + +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +¡Asegúrese de probar también esto por su cuenta! diff --git a/ebook/es/content/006-bash-comments.md b/ebook/es/content/006-bash-comments.md new file mode 100644 index 0000000..1ccc07c --- /dev/null +++ b/ebook/es/content/006-bash-comments.md @@ -0,0 +1,27 @@ +# Comentarios en Bash + +Como con cualquier otro lenguaje de programación, puede agregar comentarios a su script. Los comentarios son usados para dejar notas personales en el código. + +Para hacerlo en Bash, necesita agregar el simbolo `#` al comienzo de la línea. Los comentarios nunca aparecerán en la pantalla. + +Aquí hay un ejemplo de un comentario: + +```bash +# Este es un comentario y no aparecerá en la pantalla +``` + +Ahora agreguemos algunos comentarios a nuestro script: + +```bash +#!/bin/bash + +# Pregúntele al usuario su nombre +read -p "¿Cuál es su nombre? " nombre + +# Saluda al usuario +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +Los comentarios son una excelente manera de describir algunas de las funciones más complejas directamente en sus scripts para que otras personas puedan orientarse en su código con facilidad. + diff --git a/ebook/es/content/007-bash-arguments.md b/ebook/es/content/007-bash-arguments.md new file mode 100644 index 0000000..4b1ff43 --- /dev/null +++ b/ebook/es/content/007-bash-arguments.md @@ -0,0 +1,78 @@ +# Argumentos en Bash + +Puede pasar argumentos a su script de shell cuando lo ejecuta. Para pasar un argumento, solo necesita escribirlo justo después del nombre de su script. Por ejemplo: + +```bash +./devdojo.com su_argumento +``` + +En el script, podemos usar `$1` para hacer referencia al primer argumento que especificamos. + +Si pasamos un segundo argumento, estaría disponible como `$2` y así sucesivamente. + +Vamos a crear un script corto llamado `argumentos.sh` como ejemplo: + +```bash +#!/bin/bash + +echo "Argumento uno es $1" +echo "Argumento dos es $2" +echo "Argumento tres es $3" +``` + +Guarde el archivo y hágalo ejecutable: + +```bash +chmod +x argumentos.sh +``` + +Luego ejecute el archivo y pase **3** argumentos: + +```bash +./argumentos.sh perro gato pájaro +``` + +El resultado debería ser: + +```bash +Argumento uno es perro +Argumento dos es gato +Argumento tres es pájaro +``` + +Para hacer referencia a todos los argumentos, puede usar `$@`: + +```bash +#!/bin/bash + +echo "Todos los argumentos: $@" +``` + +Si ejecuta el script nuevamente: + +```bash +./argumentos.sh perro gato pájaro +``` + +El resultado debería ser: + +``` +Todos los argumentos: perro gato pájaro +``` + +Otra cosa que debe tener en cuenta es que `$0` se usa para hacer referencia al script en sí. + +Esta es una excelente manera de autodestruir el archivo si lo necesita o simplemente obtener el nombre del script. + +Por ejemplo, creemos un script que imprima el nombre del archivo y lo elimine después de eso: + +```bash +#!/bin/bash + +echo "El nombre del archivo es: $0 y se va a autoeliminar." + +rm -f $0 +``` + +Debe tener cuidado con la eliminación automática y asegurarse de tener una copia de seguridad de su script antes de eliminarlo automáticamente. + diff --git a/ebook/es/content/008-bash-arrays.md b/ebook/es/content/008-bash-arrays.md new file mode 100644 index 0000000..49137a3 --- /dev/null +++ b/ebook/es/content/008-bash-arrays.md @@ -0,0 +1,111 @@ +# Matrices en Bash + +Si alguna vez ha hecho algo de programación, probablemente ya está familiarizado con matrices. + +Pero en caso de que no sea un desarrollador, lo principal que debe saber es que, a diferencia de las variables, las matrices pueden contener varios valores bajo un mismo nombre. + +Puede inicializar una matriz asignando valores divididos por espacio y encerrados en `()`. Ejemplo: + +```bash +mi_matriz=("valor 1" "valor 2" "valor 3" "valor 4") +``` + +Para acceder a los elementos de la matriz, debe hacer referencia a ellos por su índice numérico. + +>{aviso} tenga en cuenta que necesita usar corchetes. + +* Accede a un solo elemento, esto daría como resultado: `valor 2` + +```bash +echo ${mi_matriz[1]} +``` + +Esto devolvería el último elemento: `valor 4` + +```bash +echo ${mi_matriz[-1]} +``` + +* Al igual que con los argumentos de la línea de comandos, usar `@` devolverá todos los argumentos en la matriz, de la siguiente manera: `valor 1 valor 2 valor 3 valor 4` + +```bash +echo ${mi_matriz[@]} +``` + +* Anteponiendo a la matriz un signo de numeral (`#`) daría como resultado el número total de elementos en la matriz, en nuestro caso es `4`: + +```bash +echo ${#mi_matriz[@]} +``` + +Asegúrese de probar esto y practicarlo con diferentes valores. + +## Subcadena en Bash :: Rebanar + +Revisemos el siguiente ejemplo de cortar una cadena de texto en Bash: + +```bash +#!/bin/bash + +letras=( "A""B""C""D""E" ) +echo ${letras[@]} +``` + +Este comando imprimirá todos los elementos de una matriz. + +Resultado: + +```bash +$ ABCDE +``` + + +Veamos algunos ejemplos más: + +- Ejemplo 1 + +```bash +#!/bin/bash + +letras=( "A""B""C""D""E" ) +b=${letras:0:2} +echo "${b}" +``` + +Este comando imprimirá una matriz desde el índice inicial 0 hasta el 2, donde 2 es exclusivo. + +```bash +$ AB +``` + +- Ejemplo 2 + +```bash +#!/bin/bash + +letras=( "A""B""C""D""E" ) +b=${letras::5} +echo "${b}" +``` + +Este comando imprimirá desde el índice base 0 a 5, donde 5 es exclusivo y el índice inicial está predeterminado en 0. + +```bash +$ ABCDE +``` + +- Ejemplo 3 + +```bash +#!/bin/bash + +letras=( "A""B""C""D""E" ) +b=${letras:3} +echo "${b}" +``` + +Este comando imprimirá desde el índice inicial 3 hasta el final de la matriz inclusive. + + ```bash + $ DE + ``` diff --git a/ebook/es/content/009-bash-conditional-expressions.md b/ebook/es/content/009-bash-conditional-expressions.md new file mode 100644 index 0000000..64f0f56 --- /dev/null +++ b/ebook/es/content/009-bash-conditional-expressions.md @@ -0,0 +1,186 @@ +# Expresiones Condicionales en Bash + +En informática, las declaraciones condicionales, las expresiones condicionales y las construcciones condicionales son características de un lenguaje de programación, que realizan diferentes cálculos o acciones dependiendo de si una condición booleana especificada por el programador se evalúa como verdadera o falsa. + +En Bash, las expresiones condicionales son utilizadas por el comando compuesto `[[` y los comandos integrados `[` para probar los atributos del archivo y realizar comparaciones aritméticas y de cadenas. + +Aquí hay una lista de las expresiones condicionales de Bash más populares. +No tiene que memorizarlos. ¡Simplemente, puede volver a consultar esta lista cuando la necesite! + +## Expresiones de Archivo + +* Verdadero si el archivo existe. + +```bash +[[ -a ${file} ]] +``` + +* Verdadero si el archivo existe y es un archivo especial de bloque. + +```bash +[[ -b ${file} ]] +``` + +* Verdadero si el archivo existe y es un archivo especial de caracteres. + +```bash +[[ -c ${file} ]] +``` + +* Verdadero si el archivo existe y es un directorio. + +```bash +[[ -d ${file} ]] +``` + +* Verdadero si el archivo existe. + +```bash +[[ -e ${file} ]] +``` + +* Verdadero si el archivo existe y es un archivo normal. + +```bash +[[ -f ${file} ]] +``` + +* Verdadero si el archivo existe y es un enlace simbólico. + +```bash +[[ -h ${file} ]] +``` + +* Verdadero si el archivo existe y es legible. + +```bash +[[ -r ${file} ]] +``` + +* Verdadero si el archivo existe y tiene un tamaño mayor que cero. + +```bash +[[ -s ${file} ]] +``` + +* Verdadero si el archivo existe y se puede escribir. + +```bash +[[ -w ${file} ]] +``` + +* Verdadero si el archivo existe y es ejecutable. + +```bash +[[ -x ${file} ]] +``` + +* Verdadero si el archivo existe y es un enlace simbólico. + +```bash +[[ -L ${file} ]] +``` + +## Expresiones de Cadena + +* Verdadero si la variable de shell `varname` está configurada (se le ha asignado un valor). + +```bash +[[ -v ${varname} ]] +``` + +* Verdadero si la longitud de la cadena es cero. + +```bash +[[ -z ${string} ]] +``` + +* Verdadero si la longitud de la cadena no es cero. + +```bash +[[ -n ${string} ]] +``` + +* Verdadero si las cadenas son iguales. `=` debe usarse con el comando de prueba para la conformidad con POSIX. Cuando se utiliza con el comando `[[`, este realiza la coincidencia de patrones como se describe arriba (Comandos compuestos). + +```bash +[[ ${string1} == ${string2} ]] +``` + +* Verdadero si las cadenas no son iguales. + +```bash +[[ ${string1} != ${string2} ]] +``` + +* Verdadero si `string1` se ordena lexicográficamente antes que `string2`. + +```bash +[[ ${string1} < ${string2} ]] +``` + +* Verdadero si `string1` se ordena después de `string2` lexicográficamente. + +```bash +[[ ${string1} > ${string2} ]] +``` + +## Operadores Aritméticos + +* Devuelve verdadero si los números son **iguales**. + +```bash +[[ ${arg1} -eq ${arg2} ]] +``` + +* Devuelve verdadero si los números **no son iguales**. + +```bash +[[ ${arg1} -ne ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **menor que** arg2. + +```bash +[[ ${arg1} -lt ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **menor o igual** arg2. + +```bash +[[ ${arg1} -le ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **mayor que** arg2. + +```bash +[[ ${arg1} -gt ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **mayor o igual** arg2 + +```bash +[[ ${arg1} -ge ${arg2} ]] +``` + +Como nota al margen, arg1 y arg2 pueden ser números enteros positivos o negativos. + +Al igual que con otros lenguajes de programación, puede usar las condiciones `AND` y `OR`: + +```bash +[[ test_case_1 ]] && [[ test_case_2 ]] # And +[[ test_case_1 ]] || [[ test_case_2 ]] # Or +``` + +## Operadores de estado de salida + +* devuelve verdadero si el comando fue exitoso sin ningún error + +```bash +[[ $? -eq 0 ]] +``` + +* devuelve verdadero si el comando no tuvo éxito o tuvo errores + +```bash +[[ $? -gt 0 ]] diff --git a/ebook/es/content/010-bash-conditionals.md b/ebook/es/content/010-bash-conditionals.md new file mode 100644 index 0000000..8d5ddf4 --- /dev/null +++ b/ebook/es/content/010-bash-conditionals.md @@ -0,0 +1,188 @@ +# Condicionales de Bash + +En la última sección, hemos cubierto algunas de las expresiones condicionales más populares. Ahora podemos usarlas con sentencias condicionales estándar como `if`, `if-else` y `switch case`. + +## Sentencia If + +El formato de una sentencia `if` en Bash es el siguiente: + +```bash +if [[ condicion ]] +then + +fi +``` + +Aquí hay un ejemplo rápido que le pedirá que introduzca su nombre en caso de que lo haya dejado vacío: + +```bash +#!/bin/bash + +# Ejemplo de sentencia if en Bash + +read -p "¿Cuál es su nombre? " nombre + +if [[ -z ${nombre} ]] +then + echo "¡Por favor, escriba su nombre!" +fi +``` + +## Sentencia If Else + +Con una sentencia `if-else`, puede especificar una acción en caso de que la condición de la sentencia `if` no se cumpla. Podemos combinar esto con las expresiones condicionales de la sección anterior de la siguiente manera: + +```bash +#!/bin/bash + +# Ejemplo de sentencia if en Bash + +read -p "¿Cuál es su nombre? " nombre + +if [[ -z ${nombre} ]] +then + echo "¡Por favor, introduzca su nombre!" +else + echo "Hola ${nombre}" +fi +``` + +Puede utilizar la sentencia if anterior con todas las expresiones condicionales de los capítulos anteriores: + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Introduzca su nombre de usuario " usuario + +# Comprueba si el nombre de usuario proporcionado es el del administrador + +if [[ "${usuario}" == "${admin}" ]] ; then + echo "¡Usted es el usuario administrador!" +else + echo "¡Usted NO es el usuario administrador!" +fi +``` + +Aquí hay otro ejemplo de una sentencia `if` que comprobaría su actual `ID de usuario` y no le permitiría ejecutar el script como el usuario `root`: + +```bash +#!/bin/bash + +if (( $EUID == 0 )); then + echo "Por favor, no ejecutar como usuario root" + exit +fi +``` + +Si pone esto encima de su script saldría en caso de que el EUID sea 0 y no ejecutaría el resto del script. Esto fue discutido en [el foro de la comunidad de DigitalOcean](https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script). + +También puede probar múltiples condiciones con una sentencia `if`. En este ejemplo queremos asegurarnos de que el usuario no es ni el usuario administrador ni el usuario root para asegurarnos de que el script es incapaz de causar demasiado daño. Usaremos el operador `or` en este ejemplo, señalado por `||`. Esto significa que cualquiera de las condiciones debe ser verdadera. Si usáramos el operador `and` de `&&` entonces ambas condiciones tendrían que ser verdaderas. + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Introduzca su nombre de usuario " usuario + +# Comprueba si el nombre de usuario proporcionado es el del administrador + +if [[ "${usuario}" != "${admin}" ]] || [[ $EUID != 0 ]] ; then + echo "Usted no es el usuario admin o root ¡pero por favor tenga cuidado!" +else + echo "¡Usted es el usuario administrador! ¡Esto podría ser muy destructivo!" +fi +``` + +Si tiene múltiples condiciones y escenarios, entonces puede usar la sentencia `elif` con las sentencias `if` y `else`. + +```bash +#!/bin/bash + +read -p "Introduzca un número: " num + +if [[ $num -gt 0 ]] ; then + echo "El número es positivo" +elif [[ $num -lt 0 ]] ; then + echo "El número es negativo" +else + echo "El número es 0" +fi +``` + +## Sentencias switch case + +Al igual que en otros lenguajes de programación, puede utilizar una sentencia `case` para simplificar las condiciones complejas cuando hay varias opciones diferentes. Así, en lugar de usar varias sentencias `if`, e `if-else`, puede usar una sola sentencia `case`. + +La sintaxis de la sentencia `case` de Bash tiene el siguiente aspecto: + +```bash +case $alguna_variable in + + patrón_1) + comandos + ;; + + patrón_2| patrón_3) + comandos + ;; + + *) + comandos por defecto + ;; +esac +``` + +Un rápido resumen de la estructura: + +* Todas las sentencias `case` comienzan con la palabra clave `case`. +* Al igual que la palabra clave `case`, necesita especificar una variable o una expresión seguida de la palabra clave `in`. +* Después de eso, tiene sus patrones `case`, donde necesita usar `)` para identificar el final del patrón. +* Puede especificar múltiples patrones divididos por una tubería: `|`. +* Después del patrón, usted especifica los comandos que le gustaría que se ejecutaran en caso de que el patrón coincida con la variable o la expresión que ha especificado. +* Todas las cláusulas deben terminar añadiendo `;;` al final. +* Puede tener una sentencia por defecto añadiendo un `*` como patrón. +* Para cerrar la sentencia `case`, utilice la palabra clave `esac` (case escrito al revés). + +Este es un ejemplo de una sentencia `case` de Bash: + +```bash +#!/bin/bash + +read -p "Introduzca el nombre de su marca de automóvil: " automovil + +case $automovil in + + Tesla) + echo -n "La fábrica de automóviles de ${automovil} está en EE.UU.". + ;; + + BMW | Mercedes | Audi | Porsche) + echo -n "La fábrica de automóviles de ${automovil} está en Alemania". + ;; + + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "La fábrica de automóviles de ${automovil} está en Japón". + ;; + + *) + echo -n "${automovil} es una marca de automóviles desconocida." + ;; + +esac +``` + +Con este script, pedimos al usuario que introduzca el nombre de una marca de coche como Telsa, BMW, Mercedes, etc. + +A continuación, con una sentencia `case`, comprobamos el nombre de la marca y si coincide con alguno de nuestros patrones, imprimimos la ubicación de la fábrica. + +Si el nombre de la marca no coincide con ninguna de nuestras sentencias `case`, mostraremos nuestro mensaje por defecto: `es una marca de automóviles desconocida`. + +## Conclusión + +Le aconsejo intentar modificar el script y jugar con él un poco ¡así puede practicar lo que ha aprendido en los últimos dos capítulos! + +Para más ejemplos de sentencias `case` de Bash, asegúrese de ir al capítulo 16, donde crearemos un menú interactivo en Bash usando sentencias `case` para procesar la entrada del usuario. + diff --git a/ebook/es/content/011-bash-loops.md b/ebook/es/content/011-bash-loops.md new file mode 100644 index 0000000..f2b2c20 --- /dev/null +++ b/ebook/es/content/011-bash-loops.md @@ -0,0 +1,199 @@ +# Bucles en Bash + +Como en cualquier otro lenguaje, los bucles son muy convenientes. Con Bash puede usar bucles `for`, bucles `while` y bucles `until`. + +## Bucles for + +Esta es la estructura de un bucle for: + +```bash +for var in ${lista} +do + comandos +done +``` + +Ejemplo: + +```bash +#!/bin/bash + +usuarios="devdojo bobby tony" + +for usuario in ${usuarios} +do + echo "${user}" +done +``` + +Un rápido resumen del ejemplo: + +* Primero, especificamos una lista de usuarios y almacenamos el valor en una variable llamada `$usuarios`. +* Después, iniciamos nuestro bucle `for` con la palabra clave `for`. +* Luego definimos una nueva variable que representaría cada elemento de la lista que damos. En nuestro caso, definimos una variable llamada `usuario`, que representaría a cada usuario de la variable `$usuarios`. +* Luego especificamos la palabra clave `in` seguida de nuestra lista que recorreremos en bucle. +* En la siguiente línea, usamos la palabra clave `do`, que indica lo que haremos en cada iteración del bucle. +* Luego especificamos los comandos que queremos ejecutar. +* Finalmente, cerramos el bucle con la palabra clave `done`. + +También puede utilizar `for` para procesar una serie de números. Por ejemplo, esta es una forma de hacer un bucle del 1 al 10: + +```bash +#!/bin/bash + +for num in {1..10} +do + echo ${num} +done +``` + +## Bucles while + +La estructura de un bucle while es bastante similar a la del bucle `for`: + +```bash +while [[ condición ]] +do + comandos +done +``` + +Este es un ejemplo de un bucle `while`: + +```bash +#!/bin/bash + +contador=1 +while [[ $contador -le 10 ]] +do + echo $contador + ((contador++)) +done +``` + +Primero, especificamos una variable contador y la pusimos a `1`, luego dentro del bucle, añadimos el contador usando esta declaración `((contador++))`. De esta manera, nos aseguramos de que el bucle se ejecutará sólo 10 veces y no se ejecutará para siempre. El bucle se completará tan pronto como el contador se convierta en 10, ya que esto es lo que hemos establecido como condición: `while [[ $contador -le 10 ]]`. + +Vamos a crear un script que pregunte al usuario por su nombre y no permita una entrada vacía: + +```bash +#!/bin/bash + +read -p "¿Cuál es su nombre? " nombre + +while [[ -z ${nombre} ]] +do + echo "Su nombre no puede estar en blanco. Por favor, introduzca un nombre válido" + read -p "Ingrese su nombre de nuevo " nombre +done + +echo "Hola ${nombre}" +``` + +Ahora, si ejecuta lo anterior y simplemente pulsa enter sin proporcionar información, el bucle se ejecutará de nuevo y le preguntará su nombre una y otra vez hasta que proporcione alguna información. + +## Bucles Until + +La diferencia entre los bucles `until` y `while` es que el bucle `until` ejecutará los comandos dentro del bucle hasta que la condición sea verdadera. + +Estructura: + +```bash +until [[ condición ]] +do + comandos +done +``` + +Ejemplo: + +```bash +#!/bin/bash + +contador=1 +until [[ $contador -gt 10 ]] +do + echo $contador + ((contador++)) +done +``` + +## Continue y Break +Al igual que con otros lenguajes, puede usar `continue` y `break` con tus scripts bash también: + +* `continue` le dice a su script bash que detenga la iteración actual del bucle y comience la siguiente iteración. + +La sintaxis de la sentencia continue es la siguiente: + +```bash +continue [n] +``` + +El argumento [n] es opcional y puede ser mayor o igual a 1. Cuando se da [n], se reanuda el n-ésimo bucle que lo rodea. continue 1 es equivalente a continue. + +```bash +#!/bin/bash + +for i in 1 2 3 4 5 +do + if [[ $i -eq 2 ]] + then + echo "saltando el número 2" + continue + fi + echo "i es igual a $i" +done +``` + +También podemos utilizar el comando continue de forma similar al comando break para controlar múltiples bucles. + + +* `break` le dice a su script bash que termine el bucle directamente. + +La sintaxis de la sentencia break tiene la siguiente forma: + +```bash +break [n] +``` +[n] es un argumento opcional y debe ser mayor o igual a 1. Cuando se proporciona [n], se sale del n-ésimo bucle que lo encierra. break 1 es equivalente a break. + +Ejemplo: + +```bash +#!/bin/bash + +num=1 +while [[ $num -lt 10 ]] +do + if [[ $num -eq 5 ]] + then + break + fi + ((num++)) +done +echo "Bucle completado" +``` + +También podemos usar el comando break con múltiples bucles. Si queremos salir del bucle actual, ya sea interno o externo, simplemente usamos break, pero si estamos en el bucle interno y queremos salir del bucle externo, usamos break 2. + +Ejemplo: + +```bash +#!/bin/bash + +for (( a = 1; a < 10; a++ )) +do + echo "bucle externo: $a" + for (( b = 1; b < 100; b++ )) + do + if [[ $b -gt 5 ]] + then + break 2 + fi + echo "bucle interno: $b " + done +done +``` + +El script bash comenzará con a=1 y pasará al bucle interno y cuando llegue a b=5, romperá el bucle externo. +Podemos usar sólo break en lugar de break 2, para romper el bucle interno y ver cómo afecta a la salida. + diff --git a/ebook/es/content/012-bash-functions.md b/ebook/es/content/012-bash-functions.md new file mode 100644 index 0000000..a353860 --- /dev/null +++ b/ebook/es/content/012-bash-functions.md @@ -0,0 +1,67 @@ +# Funciones de Bash + +Las funciones son una gran manera de reutilizar el código. La estructura de una función en bash es bastante similar a la de la mayoría de los lenguajes: + +```bash +function nombre_de_la_funcion() { + comandos +} +``` + +También puede omitir la palabra clave `function` al principio, lo que también funcionaría: + +```bash +nombre_de_la_funcion() { + comandos +} +``` + +Yo prefiero ponerlo así para una mejor legibilidad. Pero es una cuestión de preferencia personal. + +Ejemplo de una función "¡Hola Mundo!": + +```bash +#!/bin/bash + +function hola() { + echo "¡Función Hola Mundo!" +} + +hola +``` + +>{notice} Una cosa a tener en cuenta es que no debe añadir el paréntesis cuando llame a la función. + +Pasar argumentos a una función funciona de la misma manera que pasar argumentos a un script: + +```bash +#!/bin/bash + +function hola(){ + echo "¡Hola $1!" +} + +hola DevDojo +``` + +Las funciones deberían tener comentarios que mencionen la descripción, las variables globales, los argumentos, las salidas y los valores devueltos, si corresponde + +```bash +####################################### +# Descripción: Función hola +# Globales: +# Ninguno +# Entradas: +# Un argumento de entrada +# Salidas: +# Valor del argumento de entrada +# Devuelve: +# 0 si tiene éxito, distinto de cero en caso de error. +####################################### +function hola(){ + echo "¡Hola $1!" +} +``` + +¡En los próximos capítulos utilizaremos mucho las funciones! + diff --git a/ebook/es/content/013-debugging-and-testing.md b/ebook/es/content/013-debugging-and-testing.md new file mode 100644 index 0000000..b2dd09d --- /dev/null +++ b/ebook/es/content/013-debugging-and-testing.md @@ -0,0 +1,83 @@ +# Depuración, pruebas y accesos directos + +Para depurar sus scripts de bash, puede usar `-x` cuando ejecute sus scripts: + +```bash +bash -x ./su_script.sh +``` + +O puede añadir `set -x` antes de la línea específica que quiera depurar, `set -x` activa un modo del shell en el que todos los comandos ejecutados se imprimen en el terminal. + +Otra forma de probar sus scripts es usar esta fantástica herramienta: + +[https://www.shellcheck.net/](https://www.shellcheck.net/) + +Sólo tiene que copiar y pegar su código en el cuadro de texto, y la herramienta te dará algunas sugerencias sobre cómo puede mejorar su script. + +También puede ejecutar la herramienta directamente en su terminal: + +[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck) + +Si le gusta la herramienta, asegúrese de ponerle una estrella en GitHub y contribuir. + +Como SysAdmin/DevOps, paso gran parte de mi día en la terminal. Aquí están mis atajos favoritos que me ayudan a hacer tareas más rápido mientras escribo scripts Bash o simplemente mientras trabajo en la terminal. + +Los dos siguientes son particularmente útiles si tiene un comando muy largo. + +* Borrar todo desde el cursor hasta el final de la línea: + +``` +Ctrl + k +``` + +* Borrar todo desde el cursor hasta el inicio de la línea: + +``` +Ctrl + u +``` + +* Borrar una palabra hacia atrás desde el cursor: + +``` +Ctrl + w +``` + +* Buscar en el historial hacia atrás. Esta es probablemente la que más uso. Es realmente útil y acelera mucho mi flujo de trabajo: + +``` +Ctrl + r +``` + +* Borrar la pantalla, yo uso esto en lugar de escribir el comando `clear`: + +``` +Ctrl + l +``` + +* Detiene la salida a la pantalla: + +``` +Ctrl + s +``` + +* Habilita la salida a la pantalla en caso de que se haya detenido previamente con `Ctrl + s`: + +``` +Ctrl + q +``` + +* Terminar el comando actual: + +``` +Ctrl + c +``` + +* Llevar el comando actual a un segundo plano: + +``` +Ctrl + z +``` + +Yo las uso regularmente todos los días, y me ahorran mucho tiempo. + +Si cree que me he olvidado de alguna, ¡siéntase libre de unirse a la discusión en [el foro de la comunidad de DigitalOcean](https://www.digitalocean.com/community/questions/what-are-your-favorite-bash-shortcuts)! diff --git a/ebook/es/content/014-creating-custom-bash-commands.md b/ebook/es/content/014-creating-custom-bash-commands.md new file mode 100644 index 0000000..172eba2 --- /dev/null +++ b/ebook/es/content/014-creating-custom-bash-commands.md @@ -0,0 +1,83 @@ +# Creando comandos bash personalizados + +Como desarrollador o administrador del sistema, es posible que deba pasar mucho tiempo en su terminal. Siempre trato de buscar formas de optimizar las tareas repetitivas. + +Una forma de hacerlo es escribir scripts bash cortos o crear comandos personalizados, también conocidos como alias. Por ejemplo, en lugar de escribir un comando muy largo cada vez, podría crear un atajo para él. + +## Ejemplo + +Comencemos con el siguiente escenario, como administrador del sistema, es posible que deba verificar las conexiones a su servidor web con bastante frecuencia, por lo que usaré el comando `netstat` como ejemplo. + +Lo que normalmente haría cuando accedo a un servidor que tiene problemas con las conexiones al puerto 80 o 443 es verificar si hay algún servicio escuchando en esos puertos y la cantidad de conexiones a los puertos. + +El siguiente comando `netstat` nos mostraría cuántas conexiones TCP en los puertos 80 y 443 tenemos actualmente: + +```bash +netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l +``` +Este es un comando bastante largo, por lo que escribirlo cada vez puede llevar mucho tiempo a largo plazo, especialmente cuando desea obtener esa información rápidamente. + +Para evitar eso, podemos crear un alias, así que en lugar de escribir el comando completo, podríamos escribir un comando corto en su lugar. Por ejemplo, digamos que queríamos poder escribir `conx` (abreviatura de conexiones) y obtener la misma información. Todo lo que tenemos que hacer en este caso es ejecutar el siguiente comando: + +```bash +alias conx="netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +De esa manera estamos creando un alias llamado `conx` que sería esencialmente un 'atajo' para nuestro comando largo `netstat`. Ahora, si ejecuta simplemente `conx`: + +```bash +conx +``` + +Obtendría el mismo resultado que el comando largo `netstat`. +Puede ser aún más creativo y agregar algunos mensajes de información como este: + +```bash +alias conx="echo 'Total de conexiones en los puertos 80 y 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Ahora, si ejecuta `conx` obtendrá el siguiente resultado: + +```bash +Total de conexiones en los puertos 80 y 443: +12 +``` +Ahora, si cierra sesión y vuelve a iniciarla, su alias se perderá. En el siguiente paso, verá cómo hacer que esto sea persistente. + +## Hacer que el cambio sea persistente + +Para que el cambio sea persistente, debemos agregar el comando `alias` en nuestro archivo de perfil de shell. + +De forma predeterminada en Ubuntu, este sería el archivo `~/.bashrc`, para otros sistemas operativos, podría ser `~/.bash_profile`. Con tu editor de texto favorito abre el archivo: + +```bash +nano ~/.bashrc +``` + +Ve al final y agrega lo siguiente: + +```bash +alias conx="echo 'Total de conexiones en los puertos 80 y 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Guardar y luego salir. + +De esa manera, ahora, incluso si cierra sesión y vuelve a iniciar sesión, su cambio se mantendrá y podrá ejecutar su comando bash personalizado. + +## Listado de todos los alias disponibles + +Para enumerar todos los alias disponibles para su shell actual, solo tiene que ejecutar el siguiente comando: + +```bash +alias +``` + +Esto sería útil en caso de que vea algún comportamiento extraño con algunos comandos. + +## Conclusión + +Esta es una forma de crear comandos bash personalizados o alias bash. + +Por supuesto, podría escribir un script bash y agregar el script dentro de su carpeta `/usr/bin`, pero esto no funcionaría si no tiene acceso root o sudo, mientras que con los alias puede hacerlo sin la necesidad de acceso root. + +>{aviso} Esto se publicó inicialmente en [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-create-custom-bash-commands) diff --git a/ebook/es/content/015-writing-your-first-bash-script.md b/ebook/es/content/015-writing-your-first-bash-script.md new file mode 100644 index 0000000..188e6f7 --- /dev/null +++ b/ebook/es/content/015-writing-your-first-bash-script.md @@ -0,0 +1,180 @@ +# Escribe tu primer script en Bash + +Vamos a intentar agrupar lo que hemos aprendido hasta ahora y crear nuestro primer script en Bash + +## Planeando el script + +Como ejemplo, escribiremos un script que debería recopilar alguna información útil sobre nuestro servidor como: + +* Uso del disco actual +* Uso de la CPU actual +* Uso de la RAM actual +* Controlar la versión exacta del kernel + +Siéntete libre de ajustar el script añadiendo o borrando las funcionalidades según tus necesidades. + +## Escribiendo el script + +Lo primero que necesitas hacer es crear un nuevo archivo con una extensión `.sh`. Yo crearé un archivo llamado `status.sh` ya que el script que crearemos nos dará el estado de nuestro servidor. + +Una vez hayas creado el archivo, ábrelo con tu editor de texto favorito. + +Como hemos aprendido en el capítulo 1, en la primera linea de nuestro script en Bash necesitamos especificar el llamado [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)): + +```bash +#!/bin/bash +``` + +El shebang hace dice al sistema operativo que ejecute el script con el ejecutable /bin/bash. + +## Añadiendo comentarios + +A continuación, como vimos en el capítulo 6, vamos a empezar añadiendo algunos comentarios para que la gente pueda entender fácilmente para que sirve el script. Para hacerlo de manera correcta, después del shebang, puedes añadir lo siguiente: + +```bash +#!/bin/bash + +# Script que devuelve el estado actual del servidor +``` + +## Añadiendo tu primera variable + +Ahora sigamos avanzando y apliquemos lo que hemos aprendido en el capítulo 4 añadiendo algunas variables que podríamos utilizar en todo el script. + +Para asignar un valor a una variable en bash, sólo tienes que usar el símbolo `=`. Por ejemplo, vamos a almacenar el nombre de nuestro servidor en una variable que podremos usar más adelante. + +```bash +server_name=$(hostname) +``` + +Usando `$()`le decimos a bash que interprete el comando y luego le asigne el valor a nuestra variable. + +Ahora si hacemos un `echo` de la variable veriamos el nombre actual del servidor. + +```bash +echo $server_name +``` + +## Añadiendo tu primera función + +Como ya sabrás después de leer el capítulo 12, para crear una función en bash necesitas usar la siguiente estructura: + +```bash +function function_name() { + your_commands +} +``` + +Vamos a crear una función que devuelva el uso actual de la memoria en nuestro servidor: + +```bash +function memory_check() { + echo "" + echo "The current memory usage on ${server_name} is: " + free -h + echo "" +} +``` + +Una vista rápida de la función: + +* `function memory_check() {` - Esto es como definimos la función +* `echo ""` - Aquí imprimimos una nueva línea +* `echo "The current memory usage on ${server_name} is: "` - aquí imprimimos un pequeño mensaje y la variable `$server_name` +* `}` - finalmente así es como cerramos la función. + +Una vez la función ha sido definida, para llamarla, sólo tenemos que usar el nombre de la función: + +```bash +# Define la función +function memory_check() { + echo "" + echo "The current memory usage on ${server_name} is: " + free -h + echo "" +} + +# Llama a la función +memory_check +``` + +## El desafío de agregar más funciones + +Antes de comprobar la solución, te desafío a usar la función de arriba y escribir algunas funciones por tí mismo. + +Las funciones deberían hacer lo siguiente: + +* Uso actual del disco +* Uso actual de la CPU +* Uso actual de la RAM +* Controlar la versión exacta del kernel + +Siéntete libre de usar google para obtener esa información si no estás seguro de los comandos que necesitas usar. + +Una vez que termines, siéntete libre de seguir leyendo y comprobar como lo hemos hecho para comparar los resultados. + +Ten en cuenta que hay múltiples maneras correctas de hacerlo. + +## El script de ejemplo + +Así es como se vería el resultado final: + +```bash +#!/bin/bash + +## +# script en BASH que comprueba: +# - Uso de memoria +# - Carga de CPU +# - Número de conexiones TCP +# - Versión de kernel +## + +server_name=$(hostname) + +function memory_check() { + echo "" + echo "Memory usage on ${server_name} is: " + free -h + echo "" +} + +function cpu_check() { + echo "" + echo "CPU load on ${server_name} is: " + echo "" + uptime + echo "" +} + +function tcp_check() { + echo "" + echo "TCP connections on ${server_name}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function kernel_check() { + echo "" + echo "Kernel version on ${server_name} is: " + echo "" + uname -r + echo "" +} + +function all_checks() { + memory_check + cpu_check + tcp_check + kernel_check +} + +all_checks +``` + +## Conclusión + +Hacer scripts en Bash es muy útil! No importa si eres un ingeniero, desarrollador o sólo un entusiasta de Linux, puedes usar los scripts en Bash para combinar diferentes comandos de Linux y automatizar tareas diarias, aburridas y repetitivas para poder enfocarte en cosas más productivas y divertidas. + +>{aviso} Esto fue inicialmente publicado en [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) diff --git a/ebook/es/content/016-creating-an-interactive-menu-in-bash.md b/ebook/es/content/016-creating-an-interactive-menu-in-bash.md new file mode 100644 index 0000000..128454d --- /dev/null +++ b/ebook/es/content/016-creating-an-interactive-menu-in-bash.md @@ -0,0 +1,306 @@ +# Creando un menú interactivo en Bash + +En este tutorial te enseñaré como puedes crear un menú multi-opción en Bash para que tus usuarios puedan escoger que acción debería ser ejecutada. + +Reutilizaremos algo de código del capítulo anterior, así que si no lo has leído todavía asegurate de hacerlo. + +## Planeando la funcionalidad + +Empezaremos otra vez repasando la principal funcionalidad del script: + +* Controlar el uso del disco actual +* Controlar el uso de la CPU actual +* Controlar el uso de RAM actual +* Controlar la versión exacta del kernel + +En el caso de que no lo tengas a mano, aquí está el script: + +```bash +#!/bin/bash + +## +# Menú del script en Bash que controla: +# - Uso de memoria +# - Carga de CPU +# - Número de conexiones TCP +# - Versión de kernel +## + +nombre_de_servidor=$(hostname) + +function chequeo_de_memoria() { + echo "" + echo "Uso de memória en ${nombre_de_servidor} es: " + free -h + echo "" +} + +function Chequeo_de_CPU() { + echo "" + echo "Carga de CPU en ${nombre_de_servidor} es: " + echo "" + uptime + echo "" +} + +function chequeo_tcp() { + echo "" + echo "Conexiones TCP en ${nombre_de_servidor}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function chequeo_del_kernel() { + echo "" + echo "Versión del kernel en ${nombre_de_servidor} es: " + echo "" + uname -r + echo "" +} + +function todos_los_chequeos() { + chequeo_de_memoria + chequeo_de_cpu + chequepo_tcp + chequeo_del_kernel +} +``` + +Construiremos un menú que permita al usuario escoger que función será ejecutada. + +Por supuesto, puedes ajustar la función o añadir nuevas dependiendo de lo que necesites. + +## Añadiendo colores + +Con el fin de hacer el menú un poco más 'legible' y fácil de comprender a primera vista, añadiremos algunas funciones de color. + +Al principio de tu script añade las siguientes funciones de color: + +```bash +## +# Variables de color +## +verde='\e[32m' +azul='\e[34m' +clear='\e[0m' + +## +# Funciones de color +## + +ColorGreen(){ + echo -ne $verde$1$clear +} +ColorBlue(){ + echo -ne $azul$1$clear +} +``` + +Puedes usar las funciones de color de la siguiente manera: + +```bash +echo -ne $(ColorAzul 'Escribe tu texto aquí') +``` + +La línea de encima imprimirá por pantalla un string `Escribe tu texto aquí` y será azul. + +# Añadiendo el menú + +Finalmente, para añadir el menú, crearemos una función separada con un switch case para nuestro menú de opciones: + +```bash +menu(){ +echo -ne " +Mi Menu +$(ColorVerde '1)') Uso de memoria +$(ColorVerde '2)') Carga de CPU +$(ColorVerde '3)') Número de conexiones TCP +$(ColorVerde '4)') Versión del kernel +$(ColorVerde '5)') Chequear todo +$(ColorVerde '0)') Salir +$(ColorAzul 'Selecciona una opción:') " + read a + case $a in + 1) chequeo_de_memoria ; menu ;; + 2) chequeo_de_cpu ; menu ;; + 3) chequeo_tcp ; menu ;; + 4) chequeo_del_kernel ; menu ;; + 5) todos_los_chequeos ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opción incorrecta."$clear; WrongCommand;; + esac +} +``` + +### Echemos un vistazo al código + +Primero imprimimos las opciones del menú con algún color: + +``` +echo -ne " +Mi Menu +$(ColorVerde '1)') Uso de memoria +$(ColorVerde '2)') Carga de CPU +$(ColorVerde '3)') Número de conexiones TCP +$(ColorVerde '4)') Versión del kernel +$(ColorVerde '5)') Chequear todo +$(ColorVerde '0)') Salir +$(ColorAzul 'Selecciona una opción:') " +``` + +Después leemos la respuesta del usuario y la almacenamos en la variable llamada `$a`: + +```bash + read a +``` + +Finalmente, tenemos un switch case con desencadenadores a diferentes funciones dependiendo del valor de `$a`: + +```bash + case $a in + 1) chequeo_de_memoria ; menu ;; + 2) chequeo_de_cpu ; menu ;; + 3) chequeo_tcp ; menu ;; + 4) chequeo_del_kernel ; menu ;; + 5) todos_los_chequeos ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opción incorrecta."$clear; WrongCommand;; + esac +``` + +Al final es necesario llamar a la función menú para imprimir el menú: + +```bash +# Llama a la función menú +menu +``` + +## Probando el script + +Al final tu script se verá así: + +```bash +#!/bin/bash + +## +# Menú del script en Bash que controla: +# - Uso de memoria +# - Carga de CPU +# - Número de conexiones TCP +# - Versión de kernel +## + +nombre_de_servidor=$(hostname) + +function chequeo_de_memoria() { + echo "" + echo "Uso de memória en ${nombre_de_servidor} es: " + free -h + echo "" +} + +function Chequeo_de_CPU() { + echo "" + echo "Carga de CPU en ${nombre_de_servidor} es: " + echo "" + uptime + echo "" +} + +function chequeo_tcp() { + echo "" + echo "Conexiones TCP en ${nombre_de_servidor}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function chequeo_del_kernel() { + echo "" + echo "Versión del kernel en ${nombre_de_servidor} es: " + echo "" + uname -r + echo "" +} + +function todos_los_chequeos() { + chequeo_de_memoria + chequeo_de_cpu + chequepo_tcp + chequeo_del_kernel +} + +## +# Variables de color +## +verde='\e[32m' +azul='\e[34m' +clear='\e[0m' + +## +# Funciones de color +## + +ColorVerde(){ + echo -ne $verde$1$clear +} +ColorAzul(){ + echo -ne $azul$1$clear +} + +menu(){ +echo -ne " +Mi Menu +$(ColorVerde '1)') Uso de memoria +$(ColorVerde '2)') Carga de CPU +$(ColorVerde '3)') Número de conexiones TCP +$(ColorVerde '4)') Versión del kernel +$(ColorVerde '5)') Chequear todo +$(ColorVerde '0)') Salir +$(ColorAzul 'Selecciona una opción:') " + read a + case $a in + 1) chequeo_de_memoria ; menu ;; + 2) chequeo_de_cpu ; menu ;; + 3) chequeo_tcp ; menu ;; + 4) chequeo_del_kernel ; menu ;; + 5) todos_los_chequeos ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opción incorrecta."$clear; WrongCommand;; + esac +} + + +# Llama a la función menú +menu +``` + +Para probar el script, crea un nuevo archivo con una extensión `.sh`, por ejemplo: `menu.sh`y después ejecútalo: + +```bash +bash menu.sh +``` + +La salida debe verse así: + +```bash +Mi Menu +1) Uso de memória +2) Carga de CPU +3) Número de conexiones TCP +4) Versión del kernel +5) Chequear todo +0) Salir +Selecciona una opción: +``` + +Deberás ser capaz de escoger una opción diferente de la lista y cada número deberá llamar a una función diferente del script: + +![Bonito menú interactivo de Bash](https://imgur.com/8EgxX4m.png) + +## Conclusión + +Ahora sabes cómo crear un menú en Bash e implementarlo en tus scripts para que los usuarios puedan selecionar diferentes valores. + +>{aviso} Este contenido ha sido inicialmente publicado en [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) \ No newline at end of file diff --git a/ebook/es/content/017-executing-bash-script-on-multiple-remote-server.md b/ebook/es/content/017-executing-bash-script-on-multiple-remote-server.md new file mode 100644 index 0000000..d2fbdb1 --- /dev/null +++ b/ebook/es/content/017-executing-bash-script-on-multiple-remote-server.md @@ -0,0 +1,127 @@ +# Ejecutando scripts de BASH en múltiples servidores remotos + +Cualquier comando que quieras ejecutar desde línea de comandos puede ser usado en scripts de bash. Los scripts son usados para ejecutar una serie de comandos. Bash está disponible por defecto en Linux y en los sistemas operativos de mac. + +Tenemos un escenario hipotético en el cual necesitas ejecutar un script de BASH en múltiples servidores remotos pero no quieres copiar el script en cada servidor manualmente, luego loguearte en cada servidor uno por uno y entonces ejecutar el script. + +Evidentemente usarías una herramienta como Ansible pero aprendamos como hacerlo con Bash. + +## Prerrequisitos + +Para este ejemplo usaré 3 servidores remotos con Ubuntu desplegados en Digital Ocean. Si todavía no tienes una cuenta de DigitalOcean puedes inscribirte y conseguir 100$ de crédito gratuito clicando en el siguiente enlace: + +[https://m.do.co/c/2a9bba940f39](https://m.do.co/c/2a9bba940f39) + +Una vez que tengas la cuenta de Digital Ocean lista sigue adelante y despliega 3 droplets. + +Me he adelanado y he creado 3 servidores Ubuntu: + +![Servidores Ubuntu de DigitalOcean](https://imgur.com/09xmq41.png) + +Pondré las IP's de esos servidores en un archivo `servers.txt`que usaré para crear un bucle en nuestro script de Bash. + +Si eres nuevo en DigitalOcean puedes seguir estos pasos para crear un Droplet aqui: + +* [Cómo crear un Droplet desde el panel de control de DigitalOcean (en inglés)](https://www.digitalocean.com/docs/droplets/how-to/create/) + +También puedes seguir los pasos de como hacer la configuración inicial de un servidor en este vídeo: + +* [Cómo hacer la configuración inicial de tu servidor con Ubuntu (en inglés)](https://youtu.be/7NL2_4HIgKU) + +O incluso mejor, en este articulo te explica como automatizar la configuración inicial de tu servidor con Bash: + +[Automatizando la configuración inicial de un servidor con Ubuntu 18.04 con Bash (en inglés)](https://www.digitalocean.com/community/tutorials/automating-initial-server-setup-with-ubuntu-18-04) + + +Con los 3 nuevos servidores listos podemos seguir adelante y enfocarnos en ejecutar nuestro script en Bash en todos ellos con un sólo comando. + +## El script en BASH + +Reutilizaré el script de ejemplo del anterior capítulo con algunos ligeros cambios. Simplemente ejecuta unos controles como el uso de memoria actual, el uso de CPU actual, el número de conexiones TCP y la versión del kernel. + +```bash +#!/bin/bash + +## +# Menú del script en Bash que controla: +# - Uso de memoria +# - Carga de CPU +# - Número de conexiones TCP +# - Versión de kernel +## + +nombre_de_servidor=$(hostname) + +function chequeo_de_memoria() { + echo "" + echo "Uso de memória en ${nombre_de_servidor} es: " + free -h + echo "" +} + +function Chequeo_de_CPU() { + echo "" + echo "Carga de CPU en ${nombre_de_servidor} es: " + echo "" + uptime + echo "" +} + +function chequeo_tcp() { + echo "" + echo "Conexiones TCP en ${nombre_de_servidor}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function chequeo_del_kernel() { + echo "" + echo "Versión del kernel en ${nombre_de_servidor} es: " + echo "" + uname -r + echo "" +} + +function todos_los_chequeos() { + chequeo_de_memoria + chequeo_de_cpu + chequepo_tcp + chequeo_del_kernel +} + +todos_los_chequeos +``` + +Copia el código y añádelo a un archivo llamado `remote_check.sh`. También puedes descargarlo [aquí] (https://devdojo.com/bobbyiliev/executing-bash-script-on-multiple-remote-server). + +## Ejecutando el script en todos los servidores + +Ahora que ya tenemos el script y los servidores preparados y que hemos añadido esos servidores al archivo servers.txt podemos ejecutar el siguiente comando en bucle a través de todos los servidores y ejecutar el script remotamente sin tener que copiarlo en cada servidor conectándonos de uno en uno. + + +```bash +for server in $(cat servers.txt) ; do ssh tu_usuario@${server} 'bash -s' < ./remote_check.sh ; done +``` + +Lo que el bucle hace es ir a través de cada servidor que está en el archivo servers.txt y ejecutar el siguiente comando para cada ítem de la lista: + +```bash +ssh tu_usuario@ip_del_servidor 'bash -s' < ./remote_check.sh +``` + +Obtendrás el siguiente resultado: + +![Ejecutando un script bash en múltiples servidores remotos](https://imgur.com/B1AmhUP.png) + +## Conclusión + +Este es un ejemplo muy simple de como ejecutar fácilmente un script en múltiples servidores sin tener que copiar el script en cada uno de ellos ni tener que conectarse a cada uno. + +Sin duda podrías ejecutar un script mucho más complejo y en muchos más servidores. + +Si estas interesado en la automatización, te recomendaría que revises los recursos de Ansible en la página web de DigitalOcean: + +[Recursos de Ansible (en inglés)](https://www.digitalocean.com/community/tags/ansible) + +>{aviso} Este contenido fue inicialmente publicado en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) diff --git a/ebook/es/content/018-working-with-json-in-bash-using-jq.md b/ebook/es/content/018-working-with-json-in-bash-using-jq.md new file mode 100644 index 0000000..6ae409d --- /dev/null +++ b/ebook/es/content/018-working-with-json-in-bash-using-jq.md @@ -0,0 +1,226 @@ +# Trabaja con JSON en BASH usando jq + +La herramienta de línea de comandos `jq` es un procesador de línea de comandos lígero y flexible de **JSON**. Es genial para analizar el resultado de JSON en BASH. + +Una de las mejores cosas sobre `jq`es que está escrito en C portable y no tiene ninguna dependencia. Todo lo que necesitas hacer es descargar un binario único o usar un administrador de paquetes como apt e instalarlo con un único comando. + +## Planeando el script + +Para el ejemplo en este tutorial usaré una REST API externa que devuelve un sencillo resultado en JSON llamado el [QuizAPI](https://quizapi.io/): + +> [https://quizapi.io/](https://quizapi.io/) + +Si quieres hacerlo asegúrate de conseguir una clave gratuita de la API aquí: + +> [https://quizapi.io/clientarea/settings/token](https://quizapi.io/clientarea/settings/token) + +La QuizAPI es gratuita para desarrolladores. + +## Instalando jq + +Hay muchas maneras de instalar `jq`en tu sisema. Una de las formas más directa es hacerlo usando el administrador de paquetes de tu sistema operativo. + +Aqui hay una lista de comandos que podrías necesitar dependiendo de tu sistema operativo: + +* Instala jq en Ubuntu/Debian: + +```bash +sudo apt-get install jq +``` + +* Instala jq en Fedora: + +```bash +sudo dnf install jq +``` + +* Instala jq en openSUSE: + +```bash +sudo zypper install jq +``` + +* Instala jq en Arch: + +```bash +sudo pacman -S jq +``` + +* Instala en Mac con Homebrew: + +```bash +brew install jq +``` + +* Instala en Mac con MacPort: + +```bash +port install jq +``` + +Si usas otro sistema operativo echa un vistazo a la documentación oficial en este link para más información: + +> [https://stedolan.github.io/jq/download/](https://stedolan.github.io/jq/download/) + +Una vez que ya tengas instalado jq revisa la versión actual con este comando: + +```bash +jq --version +``` + +## Analizando JSON con jq + +Con `jq`instalado y tu clave API de QuizAPI podemos analizar el resultado del JSON de la QuizAPI directamente en el terminal. + +Primero creamos una variable que almacene la clave API: + +```bash +API_KEY=YOUR_API_KEY_HERE +``` + +Con el fin de conseguir el resultado de uno de los endpoints de la QuizAPI puedes usar el comando curl: + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" +``` + +Para un resultado más específico puedes usar el generador de URL de QuizAPI: + +> [https://quizapi.io/api-config](https://quizapi.io/api-config) + +Después de ejecutar el comando curl el resultado que obtendrías se vería así: + +![Resultado sin procesar Json](https://imgur.com/KghOfzj.png) + +Puede ser dificil de leer pero gracias a la herramienta de línea de comandos de jq todo lo que necesitamos hacer es pipe del comando curl a jq y veremos un resultado con formato más agradable de JSON. + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq +``` + +> Observa el `| jq` al final. + +En este caso el resultado debería verse así: + +![bash jq formatting](https://imgur.com/ebdTtVf.png) + +Ahora se ve mucho mejor! La herramienta de línea de comandos jq da formato al resultado y añade algo de agradable colorido. + +## Obteniendo el primer elemento con jq + +Digamos que solo queremos obtener el primer elemento del resultado en JSON, para conseguirlo tenemos que especificar el índice que queremos con la siguiente sintaxis: + +```bash +jq .[0] +``` + +Si ejecutamos ahora el comando curl con pipe, otra vez, el resultado de jq .[0] sería: + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq.[0] +``` + +Obtendrás el primer elemento como vemos aquí: + +![jq obtiene el primer elemento](https://imgur.com/h9bFMAL.png) + +## Obteniendo un valor para una clave específica + +A veces querrías obtener el valor de una clave específica, digamos que en nuestro ejemplo de QuizAPI devuelve una lista de preguntas junto con las respuestas, descripción, etc... ¿Que pasaría si sólo quisieras obtener las preguntas y no el resto de información? + +Se puede hacer de una forma bastante fácil con `jq`, sólo es necesario añadir la clave después del comando jq, sería algo así: + +```bash +jq .[].question +``` + +Añadiendo `.[]` a la QuizAPI nos devuelve un array y especificando el valor .question (.pregunta) le decimos que queremos obtener todos los elementos del array. + +Lo que mostraría algo así: + +![jq obtiene un valor por una clave específica](https://imgur.com/0701wHD.png) + +Cómo puedes ver sólo obtenemos las preguntas sin el resto de valores. + +## Usando jq en un script de BASH + +Seguimos avanzando y creamos un pequeño script en bash el cual nos debería mostrar la siguiente información: + +* Obtener sólo la primera pregunta +* Obtener todas las respuestas de esa pregunta +* Guardar las respuestas en variables +* Imprimir la pregunta y las respuestas + +* Para hacer esto montamos el siguiente script: + +>{aviso} asegúrate de cambiar la API_KEY por la tuya: + +```bash +#!/bin/bash + +## +# Hacer una llamada APi a la QuizAPI y almacenar la salida en una variable +## +output=$(curl 'https://quizapi.io/api/v1/questions?apiKey=API_KEY&limit=10' 2>/dev/null) + +## +# Obtener la primera pregunta +## +output=$(echo $output | jq .[0]) + +## +# Obtener la pregunta +## +question=$(echo $output | jq .question) + +## +# Obtener las respuestas +## + +answer_a=$(echo $output | jq .answers.answer_a) +answer_b=$(echo $output | jq .answers.answer_b) +answer_c=$(echo $output | jq .answers.answer_c) +answer_d=$(echo $output | jq .answers.answer_d) + +## +# imprimir la pregunta y las respuestas +## + +echo " +Question: ${question} + +A) ${answer_a} +B) ${answer_b} +C) ${answer_c} +D) ${answer_d} + +" +``` + +Si ejecutas el script debería verse algo así: + +![Usando jq en un script de bash](https://imgur.com/LKEsrbq.png) + +Podemos ir más allá haciendolo interactivo y escogiendo la respuesta directamente en nuestro terminal. + +Ya hay un script en bash que hace esto usando la QuizAPI y `jq`: + +Echa un vistazo al script aquí: + +* [https://github.com/QuizApi/QuizAPI-BASH/blob/master/quiz.sh](https://github.com/QuizApi/QuizAPI-BASH/blob/master/quiz.sh) + +## Conclusión + +La increible herramienta de linea de comandos `jq` nos da el poder de trabajar directamente con JSON en tu terminal BASH. + +Así puedes facilmente interactuar con todo tipo de REST APIs en BASH. + +Para más información puedes echar un vistazo a la documentación oficial aquí: + +* [https://stedolan.github.io/jq/manual/](https://stedolan.github.io/jq/manual/) + +Y más información de la documentación oficial de la **QuizAPI** aquí: + +* [https://quizapi.io/docs/1.0/overview](https://quizapi.io/docs/1.0/overview) + +>{aviso} Este contenido ha sido publicado inicialmente en [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) \ No newline at end of file diff --git a/ebook/es/content/019-working-with-cloudflare-api-with-bash.md b/ebook/es/content/019-working-with-cloudflare-api-with-bash.md new file mode 100644 index 0000000..d2559a9 --- /dev/null +++ b/ebook/es/content/019-working-with-cloudflare-api-with-bash.md @@ -0,0 +1,112 @@ +# Trabajar con la API de Cloudflare en Bash + +Alojo todos mis sitios web en Droplets de **DigitalOcean** y también uso Cloudflare como mi proveedor de CDN. Uno de los beneficios de usar Cloudflare es que reduce el tráfico general a tu usuario y también oculta la dirección IP real de tu servidor detrás de su CDN. + +Mi característica personal favorita de Cloudflare es su protección DDoS gratuita. Ha salvado mis servidores varias veces de diferentes ataques DDoS. Tienen una API genial que puedes usar para habilitar y deshabilitar su protección DDoS fácilmente. + +¡Este capítulo va a ser un ejercicio! ¡Te desafío a que sigas adelante y escribas un breve script de bash que habilitaría y deshabilitaría la protección DDoS de Cloudflare para tu servidor automáticamente si es necesario! + +## Prerequisitos + +Antes de seguir esta guía, configura tu cuenta de Cloudflare y prepara tu sitio web. Si no estás seguro de cómo hacerlo, puedes seguir estos pasos de aquí (en inglés): [Crear una cuenta de Cloudflare y agregar un sitio web](https://support.cloudflare.com/hc/en-us/articles/201720164-Step-2-Create-a-Cloudflare-account-and-add-a-website). + +Una vez que tengas tu cuenta de Cloudflare, asegúrate de obtener la siguiente información: + +* Una cuenta de Cloudflare +* Clave API de Cloudflare +* ID de zona de Cloudflare + +Además, asegúrate de que curl esté instalado en tu servidor: + +```bash +curl --version +``` + +Si curl no está instalado, debes ejecutar lo siguiente: + +* Para RedHat/CentOs: + +```bash +yum install curl +``` + +* Para Debian/Ubuntu: + +```bash +apt-get install curl +``` + +## Desafío - Requisitos del script + +La secuencia de comandos debe monitorizar el uso de la CPU en tu servidor y, si el uso de la CPU aumenta según el número de vCPU, habilitaría la protección DDoS de Cloudflare automáticamente a través de la API de Cloudflare. + +Las características principales del script deben ser: + +* Comprueba la carga de la CPU del script en el servidor +* En caso de un pico de CPU, el script activa una llamada API a Cloudflare y habilita la función de protección DDoS para la zona especificada +* Después de que la carga de la CPU vuelva a la normalidad, el script deshabilitará la opción "Estoy bajo ataque" y la restablecerá a la normalidad + + +## Script de ejemplo + + +Ya he preparado un script de demostración que podrías usar como referencia. ¡Pero te animo a que intentes escribir el script tú mismo primero y luego eches un vistazo a mi script! + +Para descargar el script simplemente ejecuta el siguiente comando: + +```bash +wget https://raw.githubusercontent.com/bobbyiliev/cloudflare-ddos-protection/main/protection.sh +``` + +Abre el script con tu editor de texto favorito: + +```bash +nano protection.sh +``` + +Y actualiza los siguientes detalles con tus datos de Cloudflare: + +```bash + +CF_CONE_ID=TU_ID_DE_ZONA_DE_CLOUDFLARE +CF_EMAIL_ADDRESS=TU_CORREO_ELECTRÓNICO_DE_LA_CUENTA_DE_CLOUDFLARE +CF_API_KEY=TU_CLAVE_API_DE_CLOUDFLARE + +``` + +Después de eso, haz que el script sea ejecutable: + +```bash +chmod +x ~/protection.sh +``` + +Finalmente, configura 2 trabajos Cron para que se ejecuten cada 30 segundos. Para editar tu ejecución de crontab: + +```bash +crontab -e +``` + +Y agrega el siguiente contenido: + +```bash + +* * * * * /ruta-al-script/cloudflare/protection.sh +* * * * * ( sleep 30 ; /ruta-al-script/cloudflare/protection.sh ) + +``` + +Ten en cuenta que debes cambiar la ruta al script con la ruta real donde guardaste el script. + +## Conclusión + +Esta es una solución bastante sencilla y económica, una de las desventajas de la secuencia de comandos es que si tu servidor no responde debido a un ataque, es posible que la secuencia de comandos no se active en absoluto. + +Por supuesto, un mejor enfoque sería usar un sistema de monitorización como Nagios y, en función de las estadísticas del sistema de monitorización, puedes activar el script, ¡pero el desafío de este script podría ser una buena experiencia de aprendizaje! + +Aquí hay otro gran recurso (en inglés) sobre cómo usar la API de Discord y enviar notificaciones a su canal de Discord con un script Bash: + + +[Cómo usar Webhooks de Discord para recibir notificaciones sobre el estado de tu sitio web en Ubuntu 18.04 (En inglés)](https://www.digitalocean.com/community/tutorials/how-to-use-discord-webhooks-to-get-notifications-for-your-website-status-on-ubuntu-18-04) + +>{aviso} Este contenido se publicó inicialmente en [DevDojo (En inglés)](https://devdojo.com/bobbyiliev/bash-script-to-automatically-enable-cloudflare-ddos-protection) + diff --git a/ebook/es/content/020-nginx-and-apache-log-parser.md b/ebook/es/content/020-nginx-and-apache-log-parser.md new file mode 100644 index 0000000..05627d6 --- /dev/null +++ b/ebook/es/content/020-nginx-and-apache-log-parser.md @@ -0,0 +1,84 @@ +# BASH Script parser para resumir sus registros de acceso de NGINX y Apache + +Una de las primeras cosas que suelo hacer en caso de notar un alto uso de CPU en algunos de mis servidores Linux sería comprobar la lista de procesos con top o htop y en caso de que note una gran cantidad de procesos Apache o Nginx comprobaría rápidamente mis registros de acceso para determinar qué ha causado o está causando el pico de CPU en mi servidor o para averiguar si algo malicioso está ocurriendo. + +A veces la lectura de los registros puede ser bastante intimidante ya que el registro puede ser enorme y recorrerlo manualmente puede llevar mucho tiempo. Además, el formato crudo de los registros puede ser confuso para las personas con menos experiencia. + +Al igual que el capítulo anterior, ¡este capítulo va a ser un reto! Necesita escribir un pequeño script bash que resuma todo el registro de acceso sin necesidad de instalar ningún software adicional. + +# Requisitos del script + +Este script BASH necesita analizar y resumir tus registros de acceso y proporcionarte información muy útil como: + +* Las 20 páginas con más peticiones POST +* Las 20 páginas con más peticiones GET +* Las 20 direcciones IP más visitadas y su geolocalización + +## Script de ejemplo + +Ya he preparado un script de demostración que puede usar como referencia. Pero le animo a que primero intente escribir el script usted mismo y sólo después eche un vistazo a mi script. + +Para descargar el script, puede clonar el repositorio con el siguiente comando: + + +```bash +git clone https://github.com/bobbyiliev/quick_access_logs_summary.git +``` + +O ejecutar el siguiente comando que descargará el script en su directorio actual: + +```bash +wget https://raw.githubusercontent.com/bobbyiliev/quick_access_logs_summary/master/spike_check +``` + +El script no realiza ningún cambio en su sistema, sólo lee el contenido de su registro de acceso y lo resume para usted, sin embargo, una vez que haya descargado el archivo, asegúrese de revisar el contenido usted mismo. + +## Ejecutar el script + +Todo lo que tiene que hacer una vez descargado el script es hacerlo ejecutable y ejecutarlo. + +Para conseguirlo, ejecute el siguiente comando: + +```bash +chmod +x spike_check +``` + +Luego ejecute el script: + +```bash +./spike_check /ruta/a/su/registro_de_acceso +``` + +Asegúrese de cambiar la ruta al archivo con la ruta real a su registro de acceso. Por ejemplo, si utiliza Apache en un servidor Ubuntu, el comando exacto sería el siguiente: + +```bash +./spike_check /var/log/apache2/access.log +``` + +Si está usando Nginx el comando exacto sería casi el mismo, pero con la ruta al registro de acceso de Nginx: + +```bash +./spike_check /var/log/nginx/access.log +``` + +## Entendiendo la salida + +Una vez ejecutado el script, puede tardar un poco dependiendo del tamaño del log. + +La salida que vería debería parecerse a esto: + +![Registro de acceso resumido](https://imgur.com/WWHVMrj.png) + +Esencialmente, lo que podemos decir en este caso es que hemos recibido 16 peticiones POST a nuestro archivo xmlrpc.php, que a menudo es utilizado por los atacantes para tratar de explotar sitios web de WordPress mediante el uso de varias combinaciones de nombre de usuario y contraseña. + +En este caso concreto, no se trata de un gran ataque de fuerza bruta, pero nos da una indicación temprana y podemos tomar medidas para evitar un ataque mayor en el futuro. + +También podemos ver que había un par de direcciones IP rusas accediendo a nuestro sitio, por lo que en caso de que no espere ningún tráfico desde Rusia, es posible que desee bloquear esas direcciones IP también. + +## Conclusión + +Este es un ejemplo de un simple script BASH que te permite resumir rápidamente tus registros de acceso y determinar si algo malicioso está sucediendo. + +Por supuesto, puede que también quiera revisar manualmente los registros, ¡pero es un buen reto intentar automatizar esto con Bash! + +>{notice} Este contenido fue publicado inicialmente en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) diff --git a/ebook/es/content/021-how-to-send-emails-with-bash.md b/ebook/es/content/021-how-to-send-emails-with-bash.md new file mode 100644 index 0000000..15e1f6a --- /dev/null +++ b/ebook/es/content/021-how-to-send-emails-with-bash.md @@ -0,0 +1,95 @@ +# Enviando emails con Bash y SSMTP + +SSMTP es una herramienta que envía correos electrónicos desde un ordenador o un servidor a un host de correo configurado. + +SSMTP no es un servidor de correo electrónico en sí mismo y no recibe correos electrónicos ni gestiona una cola. + +Uno de sus usos primarios es para reenviar correo automatizado (como alertas del sistema) desde su máquina y a una dirección de correo externa. + +## Requisitos previos + +Necesitará lo siguiente para poder completar este tutorial satisfactoriamente: + +* Acceso a un servidor Ubuntu 18.04 como usuario no root con privilegios sudo y un firewall activo instalado en su servidor. Para configurarlos, consulte nuestra [Guía de configuración inicial del servidor para Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Un servidor SMTP junto con el nombre de usuario y contraseña SMTP, esto también funcionaría con el servidor SMTP de Gmail, o puede configurar su propio servidor SMTP siguiendo los pasos de este tutorial en [Cómo instalar y configurar Postfix como servidor SMTP de sólo envío en Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16-04) + +## Instalación de SSMTP + +Para instalar SSMTP, primero tendrá que actualizar su caché apt con: + +```bash +sudo apt update +``` + +Luego ejecute el siguiente comando para instalar SSMTP: + +```bash +sudo apt install ssmtp +``` + +Otra cosa que necesitaría instalar es `mailutils`, para ello ejecute el siguiente comando: + +```bash +sudo apt install mailutils +``` + +## Configurando SSMTP + +Ahora que tiene `ssmtp` instalado, para configurarlo para usar su servidor SMTP cuando envíe emails, necesita editar el fichero de configuración SSMTP. + +Utilice su editor de texto favorito para abrir el fichero `/etc/ssmtp/ssmtp.conf`: + +```bash +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Necesita incluir la configuración de su SMTP: + +``` +root=postmaster +mailhub=<^>su_host_smtp.com<^>:587 +hostname=<^>su_nombre_de_host<^> +AuthUser=<^>su_usuario_gmail@su_host_smtp.com<^> +AuthPass=<^>su_password_gmail<^> +FromLineOverride=YES +UseSTARTTLS=YES +``` + +Guarde el archivo y salga. + +## Enviando emails con SSMTP + +Una vez realizada la configuración, para enviar un email basta con ejecutar el siguiente comando: + +```bash +echo "<^>Aquí añade el cuerpo de su email<^>" | mail -s "<^>Aquí especifique el asunto de su email<^>" <^>email_de_su_destinatario@sudominio.com<^> +``` + +Puede ejecutar esto directamente en su terminal o incluirlo en sus scripts bash. + +## Enviar un archivo con SSMTP (opcional) + +Si necesita enviar archivos como adjuntos, puede usar `mpack`. + +Para instalar `mpack` ejecute el siguiente comando: + +```bash +sudo apt install mpack +``` + +A continuación, para enviar un correo electrónico con un archivo adjunto, ejecute el siguiente comando. + +```bash +mpack -s "<^>Su asunto aquí<^>" su_archivo.zip <^>email_de_su_destinatario@sudominio.com<^> +``` + +El comando anterior enviaría un correo electrónico a `<^>email_de_su_destinatario@sudominio.com<^>` con el archivo `<^>su_archivo.zip<^>` como adjunto. + +## Conclusión + +SSMTP es una excelente y confiable manera de implementar la funcionalidad de correo SMTP directamente en scripts bash. + +Para más información sobre SSMTP recomiendo consultar la documentación oficial [aquí](https://wiki.archlinux.org/index.php/SSMTP). + +>Aviso Este contenido fue publicado inicialmente en el [foro de la comunidad DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp). diff --git a/ebook/es/content/022-bash-password-generator.md b/ebook/es/content/022-bash-password-generator.md new file mode 100644 index 0000000..4f4cacd --- /dev/null +++ b/ebook/es/content/022-bash-password-generator.md @@ -0,0 +1,126 @@ +# Script de Bash: Generador de contraseñas + +Es común la situación en la que necesitará generar una contraseña aleatoria que pueda usar para cualquier instalación de software, o cuando se registre en cualquier sitio web. + +Hay muchas opciones con el fin de lograr esto. Puede utilizar un gestor de contraseñas, donde a menudo tiene la opción de generar una contraseña al azar, o utilizar un sitio web que puede generar la contraseña. + +También puede utilizar Bash en su terminal (línea de comandos) para generar una contraseña que pueda utilizar rápidamente. Hay muchas maneras de lograrlo y me aseguraré de cubrir algunas de ellas y dejaré que elija la opción que más se adapte a sus necesidades. + +## :warning: Seguridad + +**Este script está pensado para practicar sus habilidades con BASH. Puede divertirse haciendo proyectos simples con BASH, pero la seguridad no es una broma, así que por favor asegúrese de no guardar sus contraseñas en texto plano en un archivo local, ni escribirlas a mano en un pedazo de papel.** + +**Recomiendo encarecidamente a todo el mundo que utilice proveedores seguros y de confianza para generar y guardar las contraseñas. + +## Resumen del script + +Permítame primero hacer un rápido resumen de lo que nuestro script va a hacer: + +1. Tendremos la opción de elegir la longitud de los caracteres de la contraseña cuando se ejecute el script. +2. El script generará entonces 5 contraseñas aleatorias con la longitud que se especificó en el paso 1 + +## Requisitos previos + +Necesitará un terminal bash y un editor de texto. Puede usar cualquier editor de texto como vi, vim, nano o Visual Studio Code. + +Estoy ejecutando el script localmente en mi portátil GNU/Linux pero si está usando un PC Windows puede hacer ssh a cualquier servidor de su elección y ejecutar el script allí. + +Aunque el script es bastante simple, tener algunos conocimientos básicos de BASH le ayudará a entender mejor el script y cómo funciona. + +## Generar una contraseña aleatoria +Uno de los grandes beneficios de GNU/Linux es que puede hacer un montón de cosas usando diferentes métodos. Cuando se trata de generar una cadena aleatoria de caracteres tampoco es diferente. + +Puede usar varios comandos para generar una cadena de caracteres aleatorios. Cubriré algunos de ellos y proporcionaré algunos ejemplos. + +- Usando el comando ```date```. +El comando ```date``` mostrará la fecha y hora actuales. Sin embargo, también podemos manipular la salida con el fin de utilizarla como contraseña generada aleatoriamente. Podemos generar un hash a partir de la fecha utilizando md5, sha o simplemente codificarlo usando base64. Estos son algunos ejemplos: + +``` +date | md5sum +94cb1cdecfed0699e2d98acd9a7b8f6d - +``` +Usando sha256sum: + +``` +date | sha256sum +30a0c6091e194c8c7785f0d7bb6e1eac9b76c0528f02213d1b6a5fbcc76ceff4 - +``` +Usando base64: +``` +date | base64 +0YHQsSDRj9C90YMgMzAgMTk6NTE6NDggRUVUIDIwMjEK +``` + +- También podemos usar openssl para generar bytes pseudoaleatorios y pasar la salida por base64. Un ejemplo de salida será: +``` +openssl rand -base64 10 +9+soM9bt8mhdcw== +``` +Tenga en cuenta que openssl podría no estar instalado en su sistema, por lo que es probable que necesite instalarlo primero para poder utilizarlo. + +- La forma preferida es utilizar el generador de números pseudoaleatorios - /dev/urandom ya que está pensado para la mayoría de los propósitos criptográficos. También necesitaríamos manipular la salida usando ```tr`` para traducirla. Un ejemplo de comando es: + +``` +tr -cd '[:alnum:]' < /dev/urandom | fold -w10 | head -n 1 +``` +Con este comando tomamos la salida de /dev/urandom y la traducimos con ```tr`` utilizando todas las letras y dígitos e imprimimos el número de caracteres deseado. + +## El script +Primero comenzamos el script con el shebang. Lo usamos para decirle al sistema operativo qué intérprete usar para analizar el resto del archivo. +``` +#!/bin/bash +``` +Entonces podemos continuar y pedir al usuario alguna entrada. En este caso nos gustaría saber cuántos caracteres debe tener la contraseña: + +``` +# Pregunta al usuario la longitud de la contraseña +clear +printf "\n" +read -p "¿Cuántos caracteres quiere que tenga la contraseña? " longitud_contrasena +printf "\n" +``` +Generar las contraseñas y luego imprimirla para que el usuario pueda usarla. +``` +# ¡Aquí es donde ocurre la magia! +# Generar una lista de 10 cadenas y cortarla al valor deseado proporcionado por el usuario. + +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${longitud_contrasena} | head -n 1); done + +# Imprimir las cadenas +printf "$pass_output\n" +printf "Adiós, ${USER}\n" +``` + +## El script completo: +``` +#!/bin/bash +#============================================= +# Generador de contraseñas con opción de login +#============================================= + +# Pregunta al usuario por la longitud de la cadena +clear +printf "\n" +read -p "¿Cuántos caracteres quiere que tenga la contraseña? " longitud_contrasena +printf "\n" + +# ¡Aquí es donde ocurre la magia! +# Generar una lista de 10 cadenas y cortarla al valor deseado proporcionado por el usuario. + +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${longitud_contrasena} | head -n 1); done + +# Imprimir las cadenas +printf "$pass_output\n" +printf "Adiós, ${USER}\n" +``` + +## Conclusión +Esto es más o menos cómo se puede utilizar un simple script de bash para generar contraseñas aleatorias. + +:advertencia: **Como ya se ha mencionado, por favor asegúrese de utilizar contraseñas seguras con el fin de asegurarse de que su cuenta está protegida. También, siempre que sea posible, utilice la autenticación de 2 factores, ya que esto proporcionará una capa adicional de seguridad para su cuenta. + +Aunque el script funciona correctamente, espera que el usuario introduzca los datos solicitados correctamente. Con el fin de evitar cualquier problema, tendría que hacer algunos controles más posteriores a la entrada del usuario, con el fin de asegurarse de que el script seguirá funcionando bien, incluso si la entrada proporcionada no coincide con nuestras necesidades. + +## Contribución de +[Alex Georgiev](https://twitter.com/alexgeorgiev17) + diff --git a/ebook/es/content/023-bash-redirection.md b/ebook/es/content/023-bash-redirection.md new file mode 100644 index 0000000..a57ea55 --- /dev/null +++ b/ebook/es/content/023-bash-redirection.md @@ -0,0 +1,224 @@ +# Redirección en Bash + +Un superusuario de Linux debe tener un buen conocimiento de las pipes y la redirección en Bash. Es un componente esencial del sistema y a menudo es útil en el campo de la Administración de Sistemas Linux. + +Cuando ejecuta un comando como ``ls``, ``cat``, etc., obtiene una salida en la terminal. Si escribe un comando incorrecto, pasa una bandera incorrecta o un argumento incorrecto en la línea de comandos, obtendrá un error en la terminal. +En ambos casos, se le da algo de texto. Puede parecerle "sólo texto", pero el sistema trata este texto de forma diferente. Este identificador se conoce como Descriptor de Archivo (fd). + +En Linux, hay 3 Descriptores de Archivos, **STDIN** (0); **STDOUT** (1) y **STDERR** (2). + +**STDIN** (fd: 0): Gestiona la entrada en el terminal. +**STDOUT** (fd: 1): Gestiona el texto de salida en el terminal. +**STDERR** (fd: 2): Gestiona el texto de error en el terminal. + +# Diferencia entre Pipes y Redirecciones + +Tanto *pipes* como *redirections* redirigen flujos `(descriptor de archivo)` del proceso que se está ejecutando. La principal diferencia es que las *redirecciones* tratan con `flujos de archivos`, enviando el flujo de salida a un archivo o enviando el contenido de un archivo dado al flujo de entrada del proceso. + +Por otro lado una pipe conecta dos comandos enviando el flujo de salida del primero al flujo de entrada del segundo, sin ninguna redirección especificada. + +# Redirección en Bash + +## STDIN (Entrada Estándar) +Cuando introduce algún texto de entrada para un comando que lo solicita, en realidad está introduciendo el texto en el descriptor de archivo **STDIN**. Ejecute el comando ``cat`` sin ningún argumento en la línea de comandos. +Puede parecer que el proceso se ha detenido, pero en realidad es ``cat`` preguntando por **STDIN**. ``cat`` es un programa sencillo e imprimirá el texto pasado a **STDIN**. Sin embargo, puede extender el caso de uso redirigiendo la entrada a los comandos que toman **STDIN**. + +Ejemplo con ``cat``: +``` +cat << EOF +¡Hola Mundo! +¿Cómo estás? +EOF +``` +Esto simplemente imprimirá el texto proporcionado en la terminal: +``` +¡Hola Mundo! +¿Cómo estás? +``` +Lo mismo se puede hacer con otros comandos que toman la entrada a través de STDIN. Como, ``wc``: +``` +wc -l << EOF +¡Hola Mundo! +¿Cómo estás? +EOF +``` +La bandera ``-l`` usada con ``wc`` cuenta el número de líneas. +Este bloque de código bash imprimirá el número de líneas en la terminal: +``` +2 +``` + +## STDOUT (Salida estándar) +El texto normal (que no sea error) ue aparece en la pantalla de su terminal se imprime a través del descriptor de archivo **STDOUT**. El **STDOUT** de un comando puede ser redirigido a un archivo, de tal manera que la salida del comando se escriba en un archivo en lugar de imprimirse en la pantalla de la terminal. +Esto se hace simplemente con la ayuda de los operadores ``>`` y ``>>``. + +Ejemplo: +``` +echo "¡Hola Mundo!" > archivo.txt +``` +El comando anterior no imprimirá "¡Hola Mundo!" en la terminal, en su lugar creará un archivo llamado ``archivo.txt`` y escribirá la cadena de texto "¡Hola Mundo!" en el mismo. +Esto se puede comprobar ejecutando el comando ``cat`` en el archivo ``archivo.txt``. +``` +cat archivo.txt +``` +Sin embargo, cada vez que redirija el **STDOUT** de cualquier comando varias veces al mismo archivo, eliminará el contenido existente del archivo para escribir el nuevo. + +Ejemplo: +``` +echo "¡Hola Mundo!" > archivo.txt +echo "¿Cómo estás?" > archivo.txt +``` + +Al ejecutar ``cat`` en el archivo ``archivo.txt``: +``` +cat archivo.txt +``` + +Sólo se imprimirá la cadena de texto "¿Cómo estás?". +``` +¿Cómo estás? +``` + +Esto se debe a que la cadena de text "¡Hola Mundo!" ha sido sobrescrita. +Este comportamiento puede evitarse utilizando el operador ``>>``. + +El ejemplo anterior se puede escribir como: +``` +echo "¡Hola Mundo!" > archivo.txt +echo "¿Cómo estás?" >> archivo.txt +``` + +Al ejecutar ``cat`` en el archivo ``archivo.txt``, obtendrá el resultado deseado. +``` +¡Hola Mundo! +¿Cómo estás? +``` + +Alternativamente, el operador de redirección para **STDOUT** también puede escribirse como ``1>``. Así, +``` +echo "¡Hola Mundo!" 1> file.txt +``` + +## STDERR (Error estándar) +El texto de error en la terminal se imprime a través de **STDERR**. Por ejemplo: +``` +ls --hola +``` +daría un mensaje de error. Este mensaje de error es la salida del flujo **STDERR** del comando. + +**STDERR** puede ser redirigido usando el operador ``2>``. +``` +ls --hello 2> error.txt +``` + +Este comando redirigirá el mensaje de error al archivo ``error.txt`` y lo escribirá en él. Esto puede verificarse ejecutando el comando ``cat`` en el archivo ``error.txt``. + +También puede usar el operador ``2>>`` para **STDERR** del mismo que usó ``>>`` para **STDOUT**. + +Los mensajes de error en scripts Bash pueden ser indeseables a veces. Puede elegir ignorarlos redirigiendo el mensaje de error al archivo ``/dev/null``. +``/dev/null`` es un pseudo-dispositivo que recibe texto y lo descarta inmediatamente. + +El ejemplo anterior puede escribirse de la siguiente manera para ignorar completamente el texto de error: +``` +ls --hello 2> /dev/null +``` + +Por supuesto, puede redirigir tanto **STDOUT** como **STDERR** en el mismo comando o script. +``` +./instalar_paquete.sh > salida.txt 2> error.txt +``` + +Ambos pueden ser redirigidos al mismo archivo también. +``` +./instalar_paquete.sh > archivo.txt 2> archivo.txt +``` + +También hay una forma más corta de hacer esto. +``` +./instalar_paquete.sh > archivo.txt 2>&1 +``` + +# Canalización (Piping) + +Hasta ahora hemos visto como redirigir el **STDOUT**, **STDIN** y **STDOUT** desde y hacia un archivo. +Para concatenar la salida del programa *(comando)* como entrada de otro programa *(comando) * se puede utilizar una barra vertical `|`. Esto se conoce como canalización (más popularmente por su nombre en inglés: ``piping``). + +Ejemplo: +``` +ls | grep ".txt" +``` +Este comando listará los archivos en el directorio actual y pasará la salida al comando *`grep`* que entonces filtrará la salida para mostrar sólo los archivos que contengan la cadena ".txt". + +Sintaxis: +``` +[time [-p]] [!] [comando1 [ | ó |& comando2 ] ... +``` + +También puede construir cadenas arbitrarias de comandos enlazándolos para conseguir un resultado potente. + +Este ejemplo crea un listado de todos los usuarios que poseen un archivo en un directorio dado, así como cuántos archivos y directorios poseen: +``` +ls -l /proyectos/bash_scripts | tail -n +2 | sed 's/\s\s*/ /g' | cut -d ' ' -f 3 | sort | uniq -c +``` + +Salida: +``` +8 anne +34 harry +37 tina +18 ryan +``` + +# HereDocument + +El símbolo `<<` se puede utilizar para crear un archivo temporal [heredoc] y redirigir desde él en la línea de comandos. +``` +COMANDO << EOF + ContenidoDelDocumento + ... + ... +EOF +``` +Observe que `EOF` representa el delimitador (fin de archivo) del heredoc. De hecho, podemos utilizar cualquier palabra alfanumérica en su lugar para indicar el inicio y el final del archivo. Por ejemplo, ésta es un heredoc válido: +``` +cat << palabraaleatoria1 + Este script imprimirá estas líneas en la terminal. + Tenga en cuenta que cat puede leer desde la entrada estándar. Usando este heredoc, podemos + crear un archivo temporal con estas líneas como su contenido y canalizar ello + hacia cat. +palabraaleatoria1 +``` + +Efectivamente, parecerá como si el contenido del heredoc se introdujera en el comando. Esto puede hacer el script muy limpio si múltiples líneas necesitan ser canalizadas dentro de un programa. + +Además, podemos adjuntar más pipes como se muestra: +``` +cat << palabraaleatoria1 | wc + Este script imprimirá estas líneas en la terminal. + Tenga en cuenta que cat puede leer desde la entrada estándar. Usando este heredoc, podemos + crear un archivo temporal con estas líneas como su contenido y canalizar ello + hacia cat. +palabraaleatoria1 +``` +También se pueden usar variables predefinidas dentro de los heredocs. + +# Herestrings + +Herestrings son bastante similares a heredocs pero usan `<<<`. Estos se utilizan para cadenas de una sola línea que tienen que ser canalizados en algún programa. Esto parece más limpio que heredocs ya que no tenemos que especificar el delimitador. +``` +wc <<<"esta es una forma fácil de pasar cadenas a la entrada estándar de un programa (en este caso wc)» +``` + +Al igual que los heredocs, los herestrings pueden contener variables. + +## Resumen +|**Operador** |**Descripción** | +|:---|:---| +|`>`|`Guardar la salida a un archivo`| +|`>>`|`Añadir la salida a un archivo`| +|`<`|`Leer una entrada desde un archivo`| +|`2>`|`Redirigir mensajes de error`| +|`\|`|`Enviar la salida de un programa como entrada a otro`| +|`<<`|`Canalizar múltiple líneas a un programa limpiamente`| +|`<<<`|`Canalizar una única línea a un programa limpiamente`| + diff --git a/ebook/es/ibis.php b/ebook/es/ibis.php new file mode 100644 index 0000000..2eb0509 --- /dev/null +++ b/ebook/es/ibis.php @@ -0,0 +1,34 @@ + 'Introduction to Bash Scripting', + + /** + * The author name. + */ + 'author' => 'Bobby Iliev', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'This is a sample from "Introduction to Bash Scripting" by Bobby Iliev.
+ For more information, Click here.', +]; diff --git a/ebook/fr/assets/cover.jpg b/ebook/fr/assets/cover.jpg new file mode 100644 index 0000000..d6db238 Binary files /dev/null and b/ebook/fr/assets/cover.jpg differ diff --git a/ebook/fr/assets/cover.jpg-bak b/ebook/fr/assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/fr/assets/cover.jpg-bak differ diff --git a/ebook/fr/assets/theme-dark.html b/ebook/fr/assets/theme-dark.html new file mode 100644 index 0000000..4a6cd7f --- /dev/null +++ b/ebook/fr/assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/fr/assets/theme-light.html b/ebook/fr/assets/theme-light.html new file mode 100644 index 0000000..bfb1d42 --- /dev/null +++ b/ebook/fr/assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/fr/content/001-introduction-au-bash.md b/ebook/fr/content/001-introduction-au-bash.md new file mode 100644 index 0000000..3237239 --- /dev/null +++ b/ebook/fr/content/001-introduction-au-bash.md @@ -0,0 +1,9 @@ +# Introduction au script Bash + +Bienvenue dans ce guide des fondamentaux de Bash! Dans ce **cours accéléré sur bash**, vous apprendrez les **bases de Bash** qui vous permettront de créer vos propres scripts et d'automatiser vos tâches journalières. + +Bash est un *shell* Unix et un langage de commande. Il est utilisable avec de nombreux systèmes d'exploitation dont la plupart des systèmes Linux où il est également l'interpréteur de commandes par défaut. + +Bash veut dire *Bourne-Again SHell* (Shell réincarné). Comme la plupart des shells, vous pouvez vous servir de Bash de manière interactive directement depuis votre terminal. Vous pouvez également utiliser Bash comme n'importe quel autre langage de programmation pour écrire des scripts. Ce livre vous aidera à apprendre les fondamentaux de l'écriture de scripts Bash, notamment les Variables Bash, les Saisies par l'Utilisateur, les Commentaires, les Arguments, les Tableaux, les Expressions Conditionnelles, les Conditions, les Boucles, les Fonctions, le Débogage et les Tests. + +Pour écrire des scripts Bash, vous avez juste besoin d'un terminal UNIX et d'un éditeur de texte comme Sublime Text, VS Code, ou un éditeur intégré au terminal comme vim ou nano. diff --git a/ebook/fr/content/002-structure-de-bash.md b/ebook/fr/content/002-structure-de-bash.md new file mode 100644 index 0000000..0453cec --- /dev/null +++ b/ebook/fr/content/002-structure-de-bash.md @@ -0,0 +1,25 @@ +# La Structure Bash + +Commençons par créer un nouveau fichier avec l'extension `.sh`. Par exemple, nous pouvons créer un fichier appelé `devdojo.sh`. + +Pour créer ce fichier, vous pouvez utiliser la commande `touch` : + +```bash +touch devdojo.sh +``` + +Ou vous pouvez utiliser votre éditeur de texte : + +```bash +nano devdojo.sh +``` + +Pour lancer un fichier contenant un script bash avec l'interpréteur shell, la première ligne de ce fichier doit indiquer le chemin absolu de l'exécutable bash : + +```bash +#!/bin/bash +``` + +On appelle cet en-tête un [Shebang](https://fr.wikipedia.org/wiki/Shebang). + +Le shebang sert uniquement à informer le système d'exploitation qu'il doit lancer le script avec l'exécutable `/bin/bash`. diff --git a/ebook/fr/content/003-hello-world-en-bash.md b/ebook/fr/content/003-hello-world-en-bash.md new file mode 100644 index 0000000..8cdb9f2 --- /dev/null +++ b/ebook/fr/content/003-hello-world-en-bash.md @@ -0,0 +1,40 @@ +# Hello World en Bash + +Une fois que nous avons créé notre fichier `devdojo.sh` et spécifié le shebang sur la première ligne, nous sommes prêts à créer notre premier script Bash qui affichera `Hello World`. + +Pour cela, ouvrez le fichier `devdojo.sh` et ajoutez le texte suivant après la ligne contenant `#!/bin/bash`: + +```bash +#!/bin/bash +echo "Hello World!" +``` + +Sauvegardez et fermez le fichier. + +Ensuite, rendez le script exécutable en utilisant la commande suivante : + +```bash +chmod +x devdojo.sh +``` + +Enfin, exécutez le script : + +```bash +./devdojo.sh +``` + +Vous verrez apparaitre le message "Hello World" sur votre écran. + +Une autre manière de lancer le script serait de lancer la commande suivante : + +```bash +bash devdojo.sh +``` + +Puisque Bash peut être utilisé de manière interactive, vous pouvez directement lancer la commande suivante depuis votre terminal et vous obtiendrez le même résultat : + +```bash +echo "Hello World!" +``` + +Créer un fichier de script est utile lorsque vous devez utiliser plusieurs commandes ensemble. diff --git a/ebook/fr/content/004-variables-dans-bash.md b/ebook/fr/content/004-variables-dans-bash.md new file mode 100644 index 0000000..eb48d05 --- /dev/null +++ b/ebook/fr/content/004-variables-dans-bash.md @@ -0,0 +1,86 @@ +# Les variables Bash + +Comme avec n'importe quel autre langage de programmation, vous pouvez également utiliser des variables avec Bash. Cependant, il n'y a pas de type de données et une variable en Bash peut contenir des nombres et des caractères. + +Pour assigner une valeur à une variable, tout ce que vous devez faire est utiliser le signe `=` : + +```bash +name="DevDojo" +``` + +>{n.b.} vous ne pouvez pas mettre d'espaces avant ou après le signe `=`. + +Ensuite, pour accéder à la variable, vous devez utiliser le caractère `$` et indiquer son nom comme ceci : + +```bash +echo $name +``` + +Entourer le nom de la variable avec des accolades n'est pas obligatoire mais est considéré comme une bonne pratique, je vous recommande donc de les utiliser aussi souvent que possible : + +```bash +echo ${name} +``` + +La commande ci-dessus afficherait `DevDojo` puisque c'est la valeur de notre variable. + +Maintenant, modifions notre script `devdojo.sh` pour y inclure une variable. + +Encore une fois, ouvrez le fichier avec l'éditeur de votre choix : + +```bash +nano devdojo.sh +``` + +Et modifiez le fichier pour qu'il ressemble à ceci : + +```bash +#!/bin/bash + +name="DevDojo" + +echo "Hi there $name" +``` + +Sauvegardez et lancez-le à nouveau : + +```bash +./devdojo.sh +``` + +Vous devriez voir le résultat suivant sur votre écran : + +```bash +Hi there DevDojo +``` + +Voici un résumé du script: + +* `#!/bin/bash` - d'abord, on spécifie le shebang +* `name=DevDojo` - ensuite, on définit une variable appelée `name` et on lui assigne une valeur +* `echo "Hi there $name"` - enfin, on affiche le contenu de la variable à l'écran en utilisant `echo` + +Vous pouvez également utiliser plusieurs variables : + +```bash +#!/bin/bash + +name="DevDojo" +greeting="Hello" + +echo "$greeting $name" +``` + +Sauvegardez et relancez le fichier : + +```bash +./devdojo.sh +``` + +Vous devriez voir le résultat suivant sur votre écran : + +```bash +Hello DevDojo +``` + +Notez que vous n'avez pas nécessairement besoin d'ajouter un point-virgule `;` à la fin de chaque ligne. Ça fonctionnera avec ou sans, un peu comme en JavaScript ! diff --git "a/ebook/fr/content/005-entr\303\251es-utilisateur-bash.md" "b/ebook/fr/content/005-entr\303\251es-utilisateur-bash.md" new file mode 100644 index 0000000..fea77fc --- /dev/null +++ "b/ebook/fr/content/005-entr\303\251es-utilisateur-bash.md" @@ -0,0 +1,54 @@ +# Les entrées utilisateur en Bash + +Avec le précédent script, nous avons défini une variable et nous affichons à l'écran la valeur de cette variable grâce à la commande `echo $name`. + +Maintenant nous allons demander à l'utilisateur son nom. Pour ce faire, ouvrez votre fichier avec votre éditeur de texte favori et écrivez ce script : + +```bash +#!/bin/bash + +echo "Quel est votre nom ?" +read name + +echo "Salut $name" +echo "Bienvenue sur DevDojo !" +``` + +Le script ci-dessus va demander une entrée à l'utilisateur et stocker cette entrée dans une variable. + +Ensuite, nous pouvons utiliser le texte de cette variable et afficher un message à l'utilisateur. + +La sortie de ce script sera la suivante : + +* D'abord, lancez le script : + +```bash +./devdojo.sh +``` + +* Ensuite, on vous demandera d'entrer votre nom : + +``` +Quel est votre nom ? +Bobby +``` + +* Lorsque vous avez entré votre nom, appuyez sur Entrée, et vous verrez la sortie suivante : + +``` +Salut Bobby +Bienvenue sur DevDojo ! +``` + +Pour réduire la taille du code, nous pourrions remplacer la première commande `echo` en utilisant la commande `read -p`. La commande `read` utilisée avec le drapeau `-p` affichera un message avant de demander une entrée à l'utilisateur : + +```bash +#!/bin/bash + +read -p "Quel est votre nom ? " name + +echo "Salut $name" +echo "Bienvenue sur DevDojo!" +``` + +Pensez bien à tester ce script par vous même ! \ No newline at end of file diff --git a/ebook/fr/content/006-commentaires-avec-bash.md b/ebook/fr/content/006-commentaires-avec-bash.md new file mode 100644 index 0000000..9ca2859 --- /dev/null +++ b/ebook/fr/content/006-commentaires-avec-bash.md @@ -0,0 +1,27 @@ +# Les Commentaires avec Bash + +Comme avec n'importe quel autre langage de programmation, vous pouvez ajouter des commentaires à votre script. Les commentaires servent à vous laisser des notes à l'intérieur de votre code. + +Pour écrire des commentaires en Bash, vous devez ajouter le symbole `#` au début de la ligne. Les commentaires ne seront pas affichés à l'écran. + +Voici un exemple simple de commentaire : + +```bash +# Ceci est un commentaire et ne sera pas affiché à l'écran +``` + +Continuons en ajoutant quelques commentaires à notre script : + +```bash +#!/bin/bash + +# Demander le nom de l'utilisateur + +read -p "What is your name? " name + +# Saluer l'utilisateur +echo "Hi there $name" +echo "Welcome to DevDojo!" +``` + +Les commentaires sont un bon moyen de décrire les fonctionnalités les plus complexes directement à l'intérieur de vos scripts pour que d'autres personnes puissent aisément se repérer à l'intérieur de votre code. diff --git a/ebook/fr/content/007-arguments-bash.md b/ebook/fr/content/007-arguments-bash.md new file mode 100644 index 0000000..b6b68d3 --- /dev/null +++ b/ebook/fr/content/007-arguments-bash.md @@ -0,0 +1,77 @@ +# Arguments Bash + +Vous pouvez passer des arguments à votre script shell quand vous l'exécutez. Pour passer un argument, vous devez simplement l'écrire juste après le nom de votre script. Par exemple : + +```bash +./devdojo.com votre_argument +``` + +Dans le script, nous pouvons ensuite utiliser `$1` pour faire appel au premier argument qui a été spécifié. + +Si nous passons un deuxième argument, nous y aurons accès avec la notation `$2`, et ainsi de suite. + +Maintenant, nous allons créer un script court appelé `arguments.sh` qui servira d'exemple : + +```bash +#!/bin/bash + +echo "Le premier argument est $1" +echo "Le deuxième argument est $2" +echo "Le troisième argument est $3" +``` + +Sauvegardez le fichier et rendez-le exécutable : + +```bash +chmod +x arguments.sh +``` + +Ensuite, lancez le fichier et passez **3** arguments : + +```bash +./arguments.sh chien chat oiseau +``` + +Vous devriez voir le message suivant s'afficher : + +```bash +Le premier argument est chien +Le deuxième argument est chat +Le troisième argument est oiseau +``` + +Pour accéder à tous les arguments, vous pouvez utiliser `$@` : + +```bash +#!/bin/bash + +echo "Tous les arguments : $@" +``` + +Si vous relancez le script : + +```bash +./arguments.sh chien chat oiseau +``` + +Le message suivant s'affichera : + +``` +Tous les arguments : chien chat oiseau +``` + +Notez bien que `$0` sert à référencer le nom du script lui-même. + +C'est un excellent moyen d'auto-détruire le fichier si besoin ou juste d'accéder au nom du script. + +Par exemple, créons un script qui affiche le nom du fichier et l'efface ensuite : + +```bash +#!/bin/bash + +echo "Le nom du fichier est: $0 et il va s'auto-détruire." + +rm -f $0 +``` + +Faites attention avec l'auto-destruction de fichiers et assurez-vous d'avoir une copie du fichier avant de l'auto-détruire. diff --git a/ebook/fr/content/008-bash-arrays.md b/ebook/fr/content/008-bash-arrays.md new file mode 100644 index 0000000..1083e0a --- /dev/null +++ b/ebook/fr/content/008-bash-arrays.md @@ -0,0 +1,111 @@ +# Les Arrays en Bash + +Si vous avez déjà fait de la programmation, vous savez probablement déjà ce qu'est un array. + +Mais au cas où vous ne seriez pas un développeur, le plus important est que vous sachiez que, contrairement aux variables, les arrays peuvent contenir plusieurs valeurs sous un même nom. + +Vous pouvez initialiser un array en lui assignant des valeurs séparées par des espaces et contenues dans des parenthèses `()`. Par exemple: + +```bash +mon_array=("valeur 1" "valeur 2" "valeur 3" "valeur 4") +``` + +Pour accéder aux éléments de l'array, vous devez les référencer en utilisant leur indice numérique. + +>{notice} retenez bien que vous devez utiliser des accolades `{}`. + +* Accéder à un seul élément, ce code affichera : `valeur 2` + +```bash +echo ${mon_array[1]} +``` + +* Ce code renvoie le dernier élément: `valeur 4` + +```bash +echo ${mon_array[-1]} +``` + +* Comme pour les arguments en ligne de commande, utiliser `@` renverra tous les éléments de l'array, comme suit : `valeur 1 valeur 2 valeur 3 valeur 4` + +```bash +echo ${mon_array[@]} +``` + +* Précéder le nom de l'array avec un croisillon (`#`) renverra le nombre total d'éléments dans l'array, `4` dans notre cas: + +```bash +echo ${#mon_array[@]} +``` + +Pensez bien à tester ce code et à vous entrainer avec différentes valeurs. + +## Les sous-chaînes de caractères (substrings) en Bash : Le découpage + +Regardons l'exemple suivant de découpage d'une chaîne de caractères (string) en Bash: + +```bash +#!/bin/bash + +lettres=( "A""B""C""D""E" ) +echo ${lettres[@]} +``` + +Cette commande affichera tous les éléments de l'array. + +Sortie : + +```bash +$ ABCDE +``` + + +Regardons quelques exemples supplémentaires : + +- Exemple 1 + +```bash +#!/bin/bash + +lettres=( "A""B""C""D""E" ) +b=${lettres:0:2} +echo "${b}" +``` + +Cette commande affiche l'array depuis l'indice 0 (le premier de l'array) jusqu'à 2 non inclus. + +```bash +$ AB +``` + +- Exemple 2 + +```bash +#!/bin/bash + +lettres=( "A""B""C""D""E" ) +b=${lettres::5} +echo "${b}" +``` + +Cette commande affiche les éléments depuis l'indice 0 jusqu'à 5 non inclus, l'indice de départ est initialisé à 0 par défaut. + +```bash +$ ABCDE +``` + +- Exemple 3 + +```bash +#!/bin/bash + +lettres=( "A""B""C""D""E" ) +b=${lettres:3} +echo "${b}" +``` + +Cette commande affiche les éléments depuis l'indice 3 jusqu'à la fin de l'array incluse. + + ```bash + $ DE + ``` diff --git a/ebook/fr/content/008-tableaux-bash.md b/ebook/fr/content/008-tableaux-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/009-bash-conditional-expressions.md b/ebook/fr/content/009-bash-conditional-expressions.md new file mode 100644 index 0000000..63a128f --- /dev/null +++ b/ebook/fr/content/009-bash-conditional-expressions.md @@ -0,0 +1,186 @@ +# Les Expressions Conditionnelles en Bash + +En informatique, les affirmations conditionnelles, expressions conditionnelles et constructions conditionnelles sont des fonctionnalités d'un langage de programmation qui effectuent des opérations différentes en fonction de la valeur booléenne d'une condition spécifiée par le développeur, `true` (vrai) ou `false` (faux). + +En Bash, les expressions conditionnelles utilisent les commandes `[[` et `[` pour tester les attributs d'un fichier et effectuer des comparaisons arithmétiques ou à partir de strings. + +Voici une liste des expressions conditionnelles Bash les plus populaires. Vous n'avez pas besoin de les retenir par coeur. Vous pouvez simplement vous référer à cette liste quand vous en avez besoin ! + +## Expressions à partir d'un fichier + +* Vrai si le fichier existe. + +```bash +[[ -a ${fichier} ]] +``` + +* Vrai si le fichier existe et est un fichier spécial en mode bloc (block special file). + +```bash +[[ -b ${fichier} ]] +``` + +* Vrai si le fichier existe et est un fichier spécial en mode caractère (character special file). + +```bash +[[ -c ${fichier} ]] +``` + +* Vrai si le fichier existe et est un dossier. + +```bash +[[ -d ${fichier} ]] +``` + +* Vrai si le fichier existe. + +```bash +[[ -e ${fichier} ]] +``` + +* Vrai si le fichier existe et est un fichier normal. + +```bash +[[ -f ${fichier} ]] +``` + +* Vrai si le fichier existe et est un lien symbolique. + +```bash +[[ -h ${fichier} ]] +``` + +* Vrai si le fichier existe et est lisible. + +```bash +[[ -r ${fichier} ]] +``` + +* Vrai si le fichier existe et a une taille supérieure à zéro. + +```bash +[[ -s ${fichier} ]] +``` + +* Vrai si le fichier existe et peut recevoir des écritures. + +```bash +[[ -w ${fichier} ]] +``` + +* Vrai si le fichier existe et est exécutable. + +```bash +[[ -x ${fichier} ]] +``` + +* Vrai si le fichier existe et est un lien symbolique. + +```bash +[[ -L ${fichier} ]] +``` + +## Les expressions sur des strings + +* Vrai si la variable varname existe (on lui a assigné une valeur). + +```bash +[[ -v ${varname} ]] +``` + +* Vrai si la string a une longueur égale à 0. + +```bash +[[ -z ${string} ]] +``` + +* Vrai si la string a une longueur différente de 0. + +```bash +[[ -n ${string} ]] +``` + +* Vrai si les strings sont égales. `=` doit être utilisé avec la commande `[` pour être conforme à la norme POSIX. Quand vous utilisez la commande `[[`, vous cherchez des correspondances de motifs entre les deux strings. + +```bash +[[ ${string1} == ${string2} ]] +``` + +* Vrai si les strings sont différentes. + +```bash +[[ ${string1} != ${string2} ]] +``` + +* Vrai si string1 précède string2 alphabétiquement. + +```bash +[[ ${string1} < ${string2} ]] +``` + +* Vrai si string1 suit string2 alphabétiquement. + +```bash +[[ ${string1} > ${string2} ]] +``` + +## Les opérateurs arithmétiques + +* Vrai si les nombres sont **égaux**. + +```bash +[[ ${arg1} -eq ${arg2} ]] +``` + +* Vrai si les nombres ne sont **pas égaux**. + +```bash +[[ ${arg1} -ne ${arg2} ]] +``` + +* Vrai si arg1 est **plus petit que** arg2. + +```bash +[[ ${arg1} -lt ${arg2} ]] +``` + +* Vrai si arg1 est **plus petit ou égal à** arg2. + +```bash +[[ ${arg1} -le ${arg2} ]] +``` + +* Vrai si arg1 est **plus grand que** arg2. + +```bash +[[ ${arg1} -gt ${arg2} ]] +``` + +* Vrai si arg1 est **plus grand ou égal à** arg2. + +```bash +[[ ${arg1} -ge ${arg2} ]] +``` + +Pour information, arg1 et arg2 peuvent être des entiers positifs ou négatifs. + +Comme avec d'autres langages de programmation, vous pouvez utiliser les conditions `AND` (et) & `OR` (ou) : + +```bash +[[ test_case_1 ]] && [[ test_case_2 ]] # And +[[ test_case_1 ]] || [[ test_case_2 ]] # Or +``` + +## Opérateurs sur le statut de fin d'une commande + +* Vrai si la commande a réussi et n'a pas rencontré d'erreur. + +```bash +[[ $? -eq 0 ]] +``` + +* Vrai si la commande n'a pas réussi ou a rencontré une erreur. + +```bash +[[ $? -gt 0 ]] +``` diff --git a/ebook/fr/content/009-structures-conditionnelles.md b/ebook/fr/content/009-structures-conditionnelles.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/010-bash-conditionals.md b/ebook/fr/content/010-bash-conditionals.md new file mode 100644 index 0000000..856544a --- /dev/null +++ b/ebook/fr/content/010-bash-conditionals.md @@ -0,0 +1,160 @@ +# Les conditions en Bash + +Dans la section précédente, nous avons couvert certaines des expressions conditionnelles les plus populaires. À présent, nous pouvons les utiliser avec les expressions conditionnelles les plus courantes telles que `if`, `if-else` et `switch case`. + +## L'expression `if` + +Le format d'une expression `if` est le suivant : + +```bash +if [[ un_test ]] +then + +fi +``` + +Voici un exemple simple qui vous demande d'entrer votre nom si vous avez laissé le champ de texte vide : + +```bash +#!/bin/bash +# Exemple de condition if en Bash +read -p "Quel est votre nom ? " nom +if [[ -z ${nom} ]] +then + echo "Veuillez entrer votre nom !" +fi +``` + +## L'expression If Else + +Avec une expression `if-else`, vous pouvez spécifier une action dans le cas où la condition dans l'expression `if` n'est pas vérifiée. Nous pouvons combiner cette notation avec les expressions conditionnelles de la section précédente : + +```bash +#!/bin/bash +# Exemple de condition if-else en Bash +read -p "Quel est votre nom ? " nom +if [[ -z ${nom} ]] +then + echo "Veuillez entrer votre nom !" +else + echo "Salut ${nom}" +fi +``` + +Vous pouvez utiliser l'expression if-else ci-dessus avec toutes les expressions conditionnelles des chapitres précédents : + +```bash +#!/bin/bash +admin="devdojo" +read -p "Entrez votre nom d'utilisateur" username +# Vérifier si le nom d'utilisateur fourni est celui de l'administrateur +if [[ "${username}" == "${admin}" ]] ; then + echo "Vous êtes l'administrateur !" +else + echo "Vous n'êtes PAS l'administrateur !" +fi +``` + +Voici un autre exemple d'une expression `if` qui vérifie votre identifiant utilisateur actuel et vous empêche de lancer le script en tant qu'utilisateur `racine` : + +```bash +#!/bin/bash +if (( $EUID == 0 )); then + echo "Veuillez ne pas lancer ce script en tant qu'utilisateur racine" + exit +fi +``` + +Si vous placez ce code en haut de votre script, il se fermera si l'EUID est égal à 0 et n'exécutera pas le reste du script. Cet élément a été discuté sur [le forum communautaire DigitalOcean](https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script) (ressource en anglais). + +Vous pouvez aussi tester de multiples conditions avec une expression `if`. Dans cet exemple, nous voulons nous assurer que l'utilisateur n'est ni l'administrateur ni l'utilisateur racine pour s'assurer que le script ne risque pas de causer trop de dégats. Nous utiliserons l'opérateur `ou` dans cet exemple, noté `||`. Cela veut dire qu'une des conditions conditions doit être vraie. Si nous utilisions l'opérateur `et` noté `&&`, alors les deux conditions devraient être vérifiées. + +```bash +#!/bin/bash +admin="devdojo" +read -p "Entrez votre nom d'utilisateur? " username +# Vérifier si le nom d'utilisateur fourni est celui de l'administrateur ou si l'EUID est celui de l'utilisateur racine +if [[ "${username}" != "${admin}" ]] || [[ $EUID != 0 ]] ; then + echo "Vous n'êtes ni l'administrateur ni l'utilisateur racine, mais faîtes quand même attention !" +else + echo "Vous êtes l'administrateur ! Ce que vous faites pourrait être dangereux !" +fi +``` + +Si vous avez plusieurs conditions et scénerios, vous pouvez utiliser l'expression `elif` à l'intérieuru d'un `if-else`. + +```bash +#!/bin/bash +read -p "Entrez un nombre : " num +if [[ $num -gt 0 ]] ; then + echo "Le nombre est positif" +elif [[ $num -lt 0 ]] ; then + echo "Le nombre est négatif" +else + echo "Le nombre est 0" +fi +``` + +## Les expressions switch case + +Comme dans d'autres langage de programmation, vous pouvez utiliser l'expression `case` pour simplifier des conditions complexes lorsqu'il y a plusieurs choix différents. Plutôt que d'utiliser de multiples `if` et `if-else`, vous pouvez utiliser une expression `case`. + +L'expression `case` avec la syntaxe Bash est écrite comme suit : + +```bash +case $une_variable in + pattern_1) + commandes + ;; + pattern_2| pattern_3) + commandes + ;; + *) + default commandes + ;; +esac +``` + +Détaillons rapidement la structure : + +* Toutes les expressions `case` commencent par le mot-clé `case`. +* Sur la même ligne que le mot-clé `case`, vous devez spécifier une variable ou une expression suivie par le mot-clé `in`. +* Ensuite, vous avez les patterns (motifs) de votre `case`, vous devez utiliser `)` pour identifier la fin du pattern. +* Vous pouvez spécifier plusieurs patterns séparés par le symbole `|`. +* Après les patterns, vous spécifiez les commandes que vous souhaitez executer quand le pattern correspond à la variable ou à l'expression que vous avez indiquée. +* Chaque clause doit se terminer par `;;`. +* Vous pouvez inclure une clause par défaut en ajoutant un `*` à la place du pattern. +* Pour fermer l'expression `case`, utilisez le mot-clé `esac` (case écrit à l'envers). + +Here is an example of a Bash `case` statement: + +```bash +#!/bin/bash +read -p "Entrez la marque de votre voiture : " voiture +case $voiture in + Tesla) + echo -n "$L'usine de {voiture} est aux États-Unis." + ;; + BMW | Mercedes | Audi | Porsche) + echo -n "$L'usine de {voiture} est en Allemagne." + ;; + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "$L'usine de {voiture} est au Japon." + ;; + *) + echo -n "${voiture} est une marque de voiture inconnue." + ;; +esac +``` + +Avec ce script, nous demandons à l'utilisateur d'entrer le nom d'une marque de voiture comme Telsa, BMW, Mercedes, etc. + +Ensuite, avec une expression `case`, nous vérifions le nom de la marque et si elle correspond à un de nos patterns, nous affichons le lieu de fabrication. + +Si le nom de la marque ne correspond à aucune de nos expressions `case`, nous affichons un message par défaut : `une marque de voiture inconnue`. + +## Conclusion + +Je vous conseille d'essayer de modifier le script pour mieux assimiler ce que vous avez appris dans les deux derniers chapitres ! + +Pour d'autres exemples d'expressions `case`, regardez le chapitre 16, où nous créons un menu interactif en Bash en nous servant d'une expression `case` pour analyser l'entrée de l'utilisateur. \ No newline at end of file diff --git a/ebook/fr/content/010-conditionnelles-en-bash.md b/ebook/fr/content/010-conditionnelles-en-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/011-boucles-en-bash.md b/ebook/fr/content/011-boucles-en-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/012-fonctions-en-bash.md b/ebook/fr/content/012-fonctions-en-bash.md new file mode 100644 index 0000000..e69de29 diff --git "a/ebook/fr/content/013-d\303\251bogage-et-test.md" "b/ebook/fr/content/013-d\303\251bogage-et-test.md" new file mode 100644 index 0000000..e69de29 diff --git "a/ebook/fr/content/014-cr\303\251ation-commandes-bash-personnalis\303\251es.md" "b/ebook/fr/content/014-cr\303\251ation-commandes-bash-personnalis\303\251es.md" new file mode 100644 index 0000000..e69de29 diff --git "a/ebook/fr/content/015-r\303\251daction-de-ton-premier-bash-script.md" "b/ebook/fr/content/015-r\303\251daction-de-ton-premier-bash-script.md" new file mode 100644 index 0000000..e69de29 diff --git "a/ebook/fr/content/016-cr\303\251ation-d-un-menu-interactif-en-bash.md" "b/ebook/fr/content/016-cr\303\251ation-d-un-menu-interactif-en-bash.md" new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/017-execution-des-scriptes-bash-sur-des-serveurs-distants-multiples.md b/ebook/fr/content/017-execution-des-scriptes-bash-sur-des-serveurs-distants-multiples.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/018-utilisation-de-jq-pour-avoir-json-en-bash.md b/ebook/fr/content/018-utilisation-de-jq-pour-avoir-json-en-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/019-utilisation-d-api-cloudflare-en-bash.md b/ebook/fr/content/019-utilisation-d-api-cloudflare-en-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/020-analyseur-de-logs-nginx-et-apache.md b/ebook/fr/content/020-analyseur-de-logs-nginx-et-apache.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/021-comment-envoyer-des-emails-avec-bash-et-ssmtp.md b/ebook/fr/content/021-comment-envoyer-des-emails-avec-bash-et-ssmtp.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/022-generateur-de-mot-de-passe-bash.md b/ebook/fr/content/022-generateur-de-mot-de-passe-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/023-redirection-avec-bash.md b/ebook/fr/content/023-redirection-avec-bash.md new file mode 100644 index 0000000..e69de29 diff --git a/ebook/fr/content/024-automatisation-de-wordpress-lamp-avec-bash.md b/ebook/fr/content/024-automatisation-de-wordpress-lamp-avec-bash.md new file mode 100644 index 0000000..e69de29 diff --git "a/ebook/fr/content/100-r\303\251capitulatif-de-bash.md" "b/ebook/fr/content/100-r\303\251capitulatif-de-bash.md" new file mode 100644 index 0000000..bdcb5f6 --- /dev/null +++ "b/ebook/fr/content/100-r\303\251capitulatif-de-bash.md" @@ -0,0 +1,15 @@ +# Récapitulatif + +Félicitations ! Vous venez de terminer le guide des fondamentaux de Bash ! + +Si vous l'avez trouvé utile, pensez à mettre une étoile sur [GitHub](https://github.com/bobbyiliev/introduction-to-bash-scripting)! + +Si vous avez une suggestion d'amélioration, n'hésitez pas à envoyer une pull request ou à ouvrir une question. + +Dans ce livre d'introduction au scripting Bash, nous avons uniquement couvert les fondamentaux, mais vous avez déjà assez de matière pour commencer à écrire dees scripts fantastiques et automatiser vos tâches quotidiennes ! + +Votre prochaine étape sera d'essayer d'écrire votre propre script et de le partager avec le monde entier ! C'est la meilleure façon d'apprendre n'importe quel langage de programmation ou de script ! + +Si ce livre vous a inspiré à écrire des super scripts Bash, n'hésitez pas à le tweeter et à identifier [@bobbyiliev_](https://twitter.com/bobbyiliev_) pour que nous puissions les voir ! + +Encore félicitations pour avoir fini ce livre ! diff --git a/ebook/fr/ibis.php b/ebook/fr/ibis.php new file mode 100644 index 0000000..59f7c15 --- /dev/null +++ b/ebook/fr/ibis.php @@ -0,0 +1,34 @@ + 'Introduction au script Bash', + + /** + * The author name. + */ + 'author' => 'Bobby Iliev', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'Extrait de "Introduction au script Bash" par Bobby Iliev.
+ Pour davantage d\'informations, Cliquez ici.', +]; diff --git a/ebook/hi/Assets/cover.jpg b/ebook/hi/Assets/cover.jpg new file mode 100644 index 0000000..d6db238 Binary files /dev/null and b/ebook/hi/Assets/cover.jpg differ diff --git a/ebook/hi/Assets/cover.jpg-bak b/ebook/hi/Assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/hi/Assets/cover.jpg-bak differ diff --git a/ebook/hi/Assets/theme-dark.html b/ebook/hi/Assets/theme-dark.html new file mode 100644 index 0000000..8b9847f --- /dev/null +++ b/ebook/hi/Assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + \ No newline at end of file diff --git a/ebook/hi/Assets/theme-light.html b/ebook/hi/Assets/theme-light.html new file mode 100644 index 0000000..2d2d73e --- /dev/null +++ b/ebook/hi/Assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + \ No newline at end of file diff --git "a/ebook/hi/content/000-\340\244\262\340\245\207\340\244\226\340\244\225-\340\244\225\340\245\207-\340\244\254\340\244\276\340\244\260\340\245\207-\340\244\256\340\245\207\340\244\202.md" "b/ebook/hi/content/000-\340\244\262\340\245\207\340\244\226\340\244\225-\340\244\225\340\245\207-\340\244\254\340\244\276\340\244\260\340\245\207-\340\244\256\340\245\207\340\244\202.md" new file mode 100644 index 0000000..605b23e --- /dev/null +++ "b/ebook/hi/content/000-\340\244\262\340\245\207\340\244\226\340\244\225-\340\244\225\340\245\207-\340\244\254\340\244\276\340\244\260\340\245\207-\340\244\256\340\245\207\340\244\202.md" @@ -0,0 +1,49 @@ +## पुस्तक के बारे में + + **यह संस्करण 1 फरवरी 2021 को प्रकाशित हुआ था।** यह एक खुल स्रोत परिचय है जो आपको बैश स्क्रिप्टिंग की मूल बातें सिखाएगा और सही तरह से बैश स्क्रिप्ट लिखने की शुरुआत करने में मदद करेगा। + ये स्क्रिप्ट आपकी दैनिक SysOps, DevOps और डेवलपमेंट कार्यों को स्वचालित करने में मदद करेंगे। आप DevOps/SysOps इंजीनियर, डेवलपर, या केवल एक लिनक्स उत्साही हैं, + तो आप बैश स्क्रिप्ट का उपयोग कर सकते हैं ताकि आप विभिन्न लिनक्स आदेशों को समन्वित कर सकें और उत्पादक और आनंददायक विषयों पर ध्यान केंद्रित कर सकें। + +## लेखक के बारे में + मेरा नाम बॉबी इलिव है, और मैं 2014 से लिनक्स डेवऑप्स इंजीनियर के रूप में काम कर रहा हूँ। मैं एक उत्साही लिनक्स प्रेमी हूँ और ओपन-सोर्स आंदोलनों के समर्थक हूँ। + मैं हमेशा उन कामों का आयोजन करता हूँ जो मैं नहीं कर सकता ताकि मैं उन्हें सीख सकूं कि उन्हें कैसे करना है, और फिर उस ज्ञान को साझा करता हूँ। + मेरा यह निश्चय है कि हमेशा पेशेवर बने रहना और अच्छे लोगों के साथ घेरा बनाए रखना जरूरी है। सबसे महत्वपूर्ण बात यह है कि हमें अपने आप को हमेशा बेहतर बनाने का प्रयास करना चाहिए और अपने काम में परिश्रम करना चाहिए, सभी के साथ अच्छा व्यवहार करना चाहिए। + आपको यह दिखाने की आवश्यकता है कि आप अपने काम में स्थिरता और उच्च उत्पादकता दिखा सकते हैं। यह एक असली पेशेवर की पहचान है। + अधिक जानकारी के लिए, कृपया मेरे ब्लॉग [https://bobbyiliev.com](https://bobbyiliev.com), पर जाएँ। + मुझे ट्विटर [@bobbyiliev_](https://twitter.com/bobbyiliev_) और [YouTube](https://www.youtube.com/channel/UCQWmdHTeAO0UvaNqve9udRw) पर फ़ॉलो करें + + +## प्रायोजक: + +इस पुस्तक को यहाँ तक पहुंचने में उन उत्कृष्ट कंपनियों का सहयोग हु + + + +## सपोन्सर्स: + +**Materialize:** +रीअल-टाइम विश्लेषण के लिए अध्ययन डेटाबेस, Materialize, वास्तविक समय में व्यू अपडेट प्रदान करने वाला है। Materialize डेवलपर्स को मानक SQL का उपयोग करके स्ट्रीमिंग डेटा के साथ आसानी से काम करने में मदद करता है। + +**डिजिटल ओशन:** +डिजिटलओशन एक क्लाउड सेवा प्लेटफार्म है जो विकासकों को प्रोडक्शन एप्लिकेशन्स को विस्तार से चलाने के लिए विश्वसनीय और सर्वोत्तम सेवाएं प्रदान करता है। यह सुरक्षित, स्थायी और विकसित भंडारण, संचय और नेटवर्किंग समाधान प्रदान करता है जो विकासकों को श्रेष्ठ सॉफ़्टवेयर बनाने में मदद करते हैं। डिजिटलओशन ने 2012 में स्थापित किया था और न्यू यॉर्क और कैम्ब्रिज, एमए के कार्यालयों के साथ संचालन कर रहा है। यह नेपथ्यपूर्ण और उचित मूल्यों वाले परिचय, एक सुंदर उपयोगकर्ता इंटरफ़ेस और ओपन सोर्स स्रोतों की सबसे बड़ी पुस्तकालयों में से एक का परिचय प्रदान करता है। अधिक जानकारी के लिए, कृपया https://www.digitalocean.com पर जाएं या Twitter पर @digitalocean को फ़ॉलो करें। यदि आप डिजिटलओशन के नए हैं, तो आप इस रेफरल लिंक के माध्यम से मुफ्त $100 क्रेडिट प्राप्त कर सकते हैं और अपने खुद के सर्वर उपकरण चालू कर सकते हैं: डिजिटलओशन के लिए मुफ्त $100 क्रेडिट + +**डेवडोजो:** +डेवडोजो वेब विकास और डिजाइन के सभी क्षेत्रों को सीखने के लिए एक संसाधन है। आप लंच ब्रेक में सीख सकते हैं या हमारे साथ उठकर एक कप कॉफी के साथ कुछ नया सीखने का आनंद ले सकते हैं। इस विकासक समुदाय का हिस्सा बनें, और हम सभी साथ में सीख सकते हैं, साथ में निर्माण कर सकते हैं, और साथ में विकसित हो सकते हैं। डेवडोजो के बारे में अधिक जानकारी के लिए, कृपया https://www.devdojo.com पर जाएं या Twitter पर @thedevdojo को फ़ॉलो करें। + +**ईबुक पीडीएफ उत्पन्न उपकरण:** +यह ईबुक Ibis द्वारा विकसित मोहम्मद सैद द्वारा उत्पन्न किया गया था। आईबिस एक PHP उपकरण है जो आपको मार्कडाउन में ईबुक लेखन में मदद करता है। + +**ईबुक ePub उत्पन्न उपकरण:** +ईबुक ePub संस्करण का निर्माण Pandoc द्वारा किया गया था। + +**पुस्तक कवर:** +इस ईबुक के लिए कवर Canva.com के साथ बनाया गया था। यदि आपको किसी ग्राफिक, पोस्टर, निमंत्रण, लोगो, प्रस्तुति - या ऐसी कोई भी चीज़ बनानी हो जो अच्छी दिखती है - तो कैनवा का उपयोग करें। + +**लाइसेंस:** +MIT लाइसेंस +कॉपीराइट (सी) 2020 बॉबी इलीव +यहाँ यह अनुमति प्रदान की जाती है कि इस सॉफ़्टवेयर और जुड़े हुए दस्तावेज़ फ़ाइलों (सॉफ़्टवेयर) की प्रति व्यक्ति को निःशुल्क रूप से प्राप्त करने का अधिकार है, सॉफ़्टवेयर के साथ किसी भी प्रतिबंध के बिना, इसमें शामिल हैं उपयोग, प्रतिलिपि, संशोधन, विलीन, प्रकाशित करने, प्रसारित करने, सबलाइसेंस करने और/या सॉफ़्टवेयर की प्रतियोगिता, और उन व्यक्तियों को जिन्हें सॉफ़्टवेयर प्रदान की जाती है, इसे करने का अधिकार है, यदि कि निम्नलिखित शर्तों का पालन करते हैं: + +उपर्युक्त कॉपीराइट नोट और यह अनुमति नोट सभी प्रतियां या महत्वपूर्ण हिस्सों में शामिल होनी चाहिए। + +सॉफ़्टवेयर "जैसा कि" है, किसी भी प्रकार की कोई भी वारंटी के बिना, ज्ञात या अज्ञात, समार्थन के लिए कोई भी वारंटी या अनुकूलन के बिना। किसी भी परिस्थिति में लेखक या कॉपीराइट धारक द्वारा दावा, क्षति या अन्य जिम्मेदारी के लिए वे विफल नहीं हो सकते, चाहे वो एक कर्मचारी हों, तोर्त या किसी अन्य रूप में, सॉफ़्टवेयर या सॉफ़्टवेयर के उपयोग या अन्य उपयोग के संबंध में या सॉफ़्टवेयर के उपयोग से हुई या संबंधित जिम्मेदारी से। \ No newline at end of file diff --git "a/ebook/hi/content/001-\340\244\254\340\245\210\340\244\266-\340\244\270\340\245\215\340\244\225\340\245\215\340\244\260\340\244\277\340\244\252\340\245\215\340\244\237\340\244\277\340\244\202\340\244\227-\340\244\225\340\244\276-\340\244\252\340\244\260\340\244\277\340\244\232\340\244\257.md" "b/ebook/hi/content/001-\340\244\254\340\245\210\340\244\266-\340\244\270\340\245\215\340\244\225\340\245\215\340\244\260\340\244\277\340\244\252\340\245\215\340\244\237\340\244\277\340\244\202\340\244\227-\340\244\225\340\244\276-\340\244\252\340\244\260\340\244\277\340\244\232\340\244\257.md" new file mode 100644 index 0000000..439f46c --- /dev/null +++ "b/ebook/hi/content/001-\340\244\254\340\245\210\340\244\266-\340\244\270\340\245\215\340\244\225\340\245\215\340\244\260\340\244\277\340\244\252\340\245\215\340\244\237\340\244\277\340\244\202\340\244\227-\340\244\225\340\244\276-\340\244\252\340\244\260\340\244\277\340\244\232\340\244\257.md" @@ -0,0 +1,11 @@ +## बैश स्क्रिप्टिंग का परिचय + +इस बैश मूल सबक प्रशिक्षण गाइड में आपका स्वागत है! इस बैश क्रैश कोर्स में, आप बैश के मूल तत्वों को सीखेंगे ताकि आप अपने खुद के बैश स्क्रिप्ट लिखना शुरू कर सकें और अपने दैनिक कार्यों को स्वचालित कर सकें। + +बैश एक यूनिक्स शैली और कमांड भाषा है। यह विभिन्न ऑपरेटिंग सिस्टमों पर व्यापक रूप से उपलब्ध है, और यह सबसे लिनक्स सिस्टमों पर डिफ़ॉल्ट कमांड इंटरप्रीटर भी है। + +बैश का शाब्दिक अर्थ है 'बोर्न-अगेन शैल'। दूसरी शैलियों की तरह, आप बैश का सीधा उपयोग अपने टर्मिनल में कर सकते हैं, और साथ ही, आप बैश को किसी अन्य प्रोग्रामिंग भाषा की तरह भी स्क्रिप्ट लिखने के लिए उपयोग कर सकते हैं। यह पुस्तक आपको बैश स्क्रिप्टिंग के मूल तत्वों के बारे में सिखाएगी, जैसे बैश वेरिएबल्स, उपयोगकर्ता इनपुट, टिप्पणियाँ, तर्क, एरे, सोपानीय अभिव्यक्तियाँ, शर्तीय वाक्यांश, शर्त, और फ़ंक्शन, डिबगिंग, और परीक्षण। + +बैश स्क्रिप्ट्स वस्तुस्थ अधिक कार्यों को स्वचालित करने के लिए बहुत उपयोगी होते हैं और आपको समय की बहुत बचत करने में मदद कर सकते हैं। उदाहरण के लिए, किसी परियोजना पर पाँच डेवलपर्स के साथ काम कर रहे हैं जिन्हें एक उद्यानपर्यंत के वातावरण की आवश्यकता है। प्रोग्राम को सही ढंग से काम करने के लिए, प्रत्येक डेवलपर को वातावरण की मैन्युअल सेटअप करना होता है। यह एक ही और बहुत लंबा कार्य (वातावरण की सेटअप) कम से कम पाँच बार दोहराया जाता है। यहाँ आप और बैश स्क्रिप्ट्स काम में आते हैं! इसके बजाय, आप एक सरल पाठ फ़ाइल बनाते हैं जिसमें सभी आवश्यक निर्देश होती हैं और इसे अपने सहयोगियों के साथ साझा करते हैं। और अब, उन्हें बस बैश स्क्रिप्ट को निष्पादित करना है और सब कुछ उनके लिए बन जाएगा। + +बैश स्क्रिप्ट लिखने के लिए आपको एक UNIX टर्मिनल और Sublime Text, VS Code जैसे पाठ संपादक या vim या nano जैसे टर्मिनल-आधारित संपादक की आवश्यकता है। \ No newline at end of file diff --git "a/ebook/hi/content/002-\340\244\254\340\245\210\340\244\266-\340\244\270\340\244\202\340\244\260\340\244\232\340\244\250\340\244\276.md" "b/ebook/hi/content/002-\340\244\254\340\245\210\340\244\266-\340\244\270\340\244\202\340\244\260\340\244\232\340\244\250\340\244\276.md" new file mode 100644 index 0000000..174d9a6 --- /dev/null +++ "b/ebook/hi/content/002-\340\244\254\340\245\210\340\244\266-\340\244\270\340\244\202\340\244\260\340\244\232\340\244\250\340\244\276.md" @@ -0,0 +1,10 @@ +## बैश संरचना +आइए एक नई फ़ाइल बनाने की शुरुआत करें जिसका एक .sh एक्सटेंशन हो। उदाहरण के रूप में, हम एक फ़ाइल बना सकते हैं जिसे डेवडोजो.sh कहा जा सकता है। +उस फ़ाइल को बनाने के लिए, आप टच कमांड का उपयोग कर सकते हैं: +`touch devdojo.sh` +या आप इसे अपने पाठ संपादक का उपयोग कर सकते हैं: +`nano devdojo.sh` +बैश स्क्रिप्ट फ़ाइल को बैश शैल अनुप्रेषक के साथ निष्पादित/चलाया जाने के लिए, स्क्रिप्ट फ़ाइल की पहली पंक्ति को बैश निष्पादक के लिए पूर्णपथ निर्दिष्ट करना आवश्यक है: +`#!/bin/bash` +इसे यह भी 'शेबैंग' कहा जाता है। +शेबैंग का यह एकमात्र कार्य है कि ऑपरेटिंग सिस्टम को सूचित करता है कि स्क्रिप्ट को /बिन/बैश निष्पादक के साथ चलाए। \ No newline at end of file diff --git "a/ebook/hi/content/003-\340\244\254\340\245\210\340\244\266-\340\244\271\340\245\210\340\244\262\340\245\213-\340\244\265\340\244\260\340\245\215\340\244\262\340\245\215\340\244\241.md" "b/ebook/hi/content/003-\340\244\254\340\245\210\340\244\266-\340\244\271\340\245\210\340\244\262\340\245\213-\340\244\265\340\244\260\340\245\215\340\244\262\340\245\215\340\244\241.md" new file mode 100644 index 0000000..5dfd62c --- /dev/null +++ "b/ebook/hi/content/003-\340\244\254\340\245\210\340\244\266-\340\244\271\340\245\210\340\244\262\340\245\213-\340\244\265\340\244\260\340\245\215\340\244\262\340\245\215\340\244\241.md" @@ -0,0 +1,32 @@ +## बैश हैलो वर्ल्ड +जब हमारी डेवडोजो.श फ़ाइल बन गई है और हमने पहली पंक्ति पर बैश शेबैंग निर्दिष्ट की है, तो हम अपनी पहली नमस्ते वर्ल्ड बैश स्क्रिप्ट बनाने के लिए तैयार हैं। + +इसे करने के लिए, पुनः devdojo.sh फ़ाइल खोलें और #!/bin/bash लाइन के बाद निम्नलिखित जोड़ें: +```bash +#!/bin/bash +echo "Hello World!" +``` +फ़ाइल सहेजें और बाहर निकलें। + +उसके बाद, निम्नलिखित कमांड द्वारा स्क्रिप्ट को क्रियाशील बनाएं: +```bash +chmod +x devdojo.sh +``` +उसके बाद फ़ाइल को निष्पादित करें: +```bash +./devdojo.sh +``` +आपको स्क्रीन पर "नमस्ते वर्ल्ड" संदेश दिखाई देगा। + +एक और तरीका स्क्रिप्ट को चलाने का यह हो सकता है: +```bash +bash devdojo.sh +``` + +18 +बैश को अंतर्क्रियात्मक रूप से उपयोग किया जा सकता है, आप अपने टर्मिनल में सीधे निम्नलिखित कमांड को चला सकते हैं और आपको एक ही परिणाम मिलेगा: +```bash +echo "नमस्ते देवडोजो!" +``` + +एक स्क्रिप्ट को एकत्रित करना उपयोगी है जब आपको कई कमांडों को एक साथ कंबाइन करना हो। \ No newline at end of file diff --git "a/ebook/hi/content/004-\340\244\254\340\245\210\340\244\266-\340\244\265\340\245\207\340\244\260\340\244\277\340\244\217\340\244\254\340\244\262\340\245\215\340\244\270.md" "b/ebook/hi/content/004-\340\244\254\340\245\210\340\244\266-\340\244\265\340\245\207\340\244\260\340\244\277\340\244\217\340\244\254\340\244\262\340\245\215\340\244\270.md" new file mode 100644 index 0000000..37d6284 --- /dev/null +++ "b/ebook/hi/content/004-\340\244\254\340\245\210\340\244\266-\340\244\265\340\245\207\340\244\260\340\244\277\340\244\217\340\244\254\340\244\262\340\245\215\340\244\270.md" @@ -0,0 +1,72 @@ +## बैश वेरिएबल्स +किसी भी अन्य प्रोग्रामिंग भाषा की तरह, आप बैश स्क्रिप्टिंग में भी वेरिएबल्स का उपयोग कर सकते हैं। हालांकि, यहाँ कोई डेटा प्रकार नहीं है, और बैश में एक वेरिएबल नंबर और वर्ण दोनों शामिल कर सकता है। + +एक वेरिएबल को मूल्य सौंपने के लिए, आपको बस = चिह्न का उपयोग करना है: +```bash +name="डेवडोजो" +``` +ध्यान दें: एक महत्वपूर्ण नोट के रूप में, = चिह्न के आस-पास स्थानों नहीं हो सकता। + +इसके बाद, वेरिएबल तक पहुँचने के लिए, आपको $ चिह्न का उपयोग करना होगा और निम्नलिखित रूप से संदर्भित करना होगा: +```bash +echo $name +``` +वेरिएबल नाम को कुवच ब्रैकेट्स के बीच रखना आवश्यक नहीं है, लेकिन यह एक अच्छी अभ्यास समझा जाता है, और मैं आपसे सलाह दूंगा कि जब भी आप इस्तेमाल कर सकें, तो इन्हें उपयोग करें: +```bash +echo ${name} +``` +उपरोक्त कोड उत्पादित करेगा: डेवडोजो क्योंकि यह हमारे नाम वेरिएबल की मूल्य है। + +आगे, चलो हमारी devdojo.sh स्क्रिप्ट को अपडेट करें और इसमें एक वेरिएबल शामिल करें। फिर से, आप अपने पसंदीदा पाठ संपादक के साथ फ़ाइल devdojo.sh खोल सकते हैं, यहाँ मैं तो नैनो उपयोग कर रहा हूँ फ़ाइल खोलने के लिए: +```bash +nano devdojo.sh +``` +यहां फ़ाइल में हमारे नाम वेरिएबल को शामिल करें, स्वागत संदेश के साथ। हमारी फ़ाइल अब इस तरह दिखती है: +```bash +#!/bin/bash +name="डेवडोजो" +echo "नमस्ते $name" +``` +इसे सहेजें और निम्नलिखित कमांड का उपयोग करके फ़ाइल को चलाएं: +```bash +./devdojo.sh +``` +आपको अपने स्क्रीन पर निम्नलिखित आउटपुट दिखेगा: +```bash +नमस्ते डेवडोजो +``` +यहाँ फ़ाइल में लिखी गई स्क्रिप्ट की एक ब्रीफ़ रनडाउन है: +- `#!/bin/bash` - पहले, हमने अपनी शेबैंग को निर्दिष्ट किया। +- `name=डेवडोजो` - तब, हमने एक वेरिएबल name निर्धारित किया और उसे एक मूल्य सौंपा। +- `echo "नमस्ते $name"` - आख़िरकार, हमने वेरिएबल की सामग्री को शास्त्र परिचय के रूप में स्क्रीन पर उत्पन्न किया, `echo` का उपयोग करके। +आप बैश स्क्रिप्ट के बाहर कमांड लाइन में भी वेरिएबल्स जोड़ सकते हैं और उन्हें पैरामीटर्स के रूप में पढ़ा जा सकता है: +```bash +./devdojo.sh बॉबी दोस्त! +``` +यह स्क्रिप्ट बॉबी और दोस्त! नामक दो पैरामीटर्स को स्वीकार करती है, जिन्हें अंतर स्थान से विभाजित किया जाता है। devdojo.sh फ़ाइल में हमारे पास निम्नलिखित है: +```bash +#!/bin/bash +echo "नमस्ते वहाँ" $1 +``` +$1 वहाँ वाले पहले इनपुट (बॉबी) को कमांड लाइन में संदर्भित करता है। इसी तरह, अधिक इनपुट्स हो सकते हैं और वे सभी $ चिह्न से संदर्भित किए जाते हैं और उनके संदर्भण क्रम के अनुसार। इसका मतलब है कि दोस्त! को $2 का उपयोग करके संदर्भित किया जाता है। वेरिएबल्स को पढ़ने के लिए एक और उपयोगी विधि $@ है जो सभी इनपुट्स को पढ़ता है। + +इसलिए अब चलो devdojo.sh फ़ाइल को बेहतर समझने के लिए बदलते हैं: +```bash +#!/bin/bash +echo "नमस्ते वहाँ" $1 +# $1 : पहला पैरामीटर +echo "नमस्ते वहाँ" $2 +# $2 : दूसरा पैरामीटर +echo "नमस्ते वहाँ" $@ +# $@ : सभी +``` +इसका आउटपुट: +```bash +./devdojo.sh बॉबी दोस्त! +``` +निम्नलिखित होगा: +```bash +नमस्ते बॉबी +नमस्ते दोस्त! +नमस्ते बॉबी दोस्त! +``` \ No newline at end of file diff --git a/ebook/hi/ibis.php b/ebook/hi/ibis.php new file mode 100644 index 0000000..a91a10c --- /dev/null +++ b/ebook/hi/ibis.php @@ -0,0 +1,34 @@ + 'बैश-स्क्रिप्टिंग-का-परिचय', + + /** + * The author name. + */ + 'author' => 'बॉबी इलिव', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'यह बॉबी इलिव द्वारा लिखित "इंट्रोडक्शन टू बैश स्क्रिप्टिंग" का एक नमूना है।
+ अधिक जानकारी के लिए, यहाँ क्लिक करें.', +]; \ No newline at end of file diff --git a/ebook/pt_br/assets/cover.jpg b/ebook/pt_br/assets/cover.jpg new file mode 100644 index 0000000..d6db238 Binary files /dev/null and b/ebook/pt_br/assets/cover.jpg differ diff --git a/ebook/pt_br/assets/cover.jpg-bak b/ebook/pt_br/assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/pt_br/assets/cover.jpg-bak differ diff --git a/ebook/pt_br/assets/theme-dark.html b/ebook/pt_br/assets/theme-dark.html new file mode 100644 index 0000000..6f12e6d --- /dev/null +++ b/ebook/pt_br/assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/pt_br/assets/theme-light.html b/ebook/pt_br/assets/theme-light.html new file mode 100644 index 0000000..561b80c --- /dev/null +++ b/ebook/pt_br/assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/pt_br/content/000-about-the-author.md b/ebook/pt_br/content/000-about-the-author.md new file mode 100644 index 0000000..6b83bd1 --- /dev/null +++ b/ebook/pt_br/content/000-about-the-author.md @@ -0,0 +1,91 @@ +# Sobre o livro + +* **Esta versão foi publicada em 01 de Fevereiro 2021** + +Esta é uma introdução de código aberto ao guia de script Bash que o ajudará a aprender os conceitos básicos de script Bash e começar a escrever scripts Bash incríveis que ajudarão você a automatizar suas tarefas diárias de SysOps, DevOps e Dev. Não importa se você é um engenheiro de DevOps/SysOps, desenvolvedor ou apenas um entusiasta do Linux, você pode usar scripts Bash para combinar diferentes comandos do Linux e automatizar tarefas diárias tediosas e repetitivas para que você possa se concentrar em coisas mais produtivas e divertidas. + +O guia é adequado para qualquer pessoa que trabalhe como desenvolvedor, administrador de sistema ou engenheiro de DevOps e queira aprender os fundamentos do script Bash. + +Os primeiros 13 capítulos seriam puramente focados em obter algumas bases sólidas de script Bash, então o restante dos capítulos forneceria alguns exemplos e scripts da vida real. + +## Sobre o autor + +Meu nome é Bobby Iliev e trabalho como Linux DevOps Engineer desde 2014. Sou um ávido amante do Linux e defensor da filosofia do movimento de código aberto. Estou sempre fazendo além do que eu posso fazer para aprender a fazer, e acredito em compartilhar conhecimento. + +Acho essencial sempre se manter profissional e se cercar de pessoas boas, trabalhar duro e ser legal com todos. Você tem que desempenhar em um nível consistentemente mais alto do que os outros. Essa é a marca de um verdadeiro profissional. + +Para mais informações, visite meu blog em [https://bobbyiliev.com](https://bobbyiliev.com), siga-me no Twitter [@bobbyiliev_](https://twitter.com/bobbyiliev_) e [YouTube](https://www.youtube.com/channel/UCQWmdHTeAO0UvaNqve9udRw). + +## Patrocinadores + +Este livro é possível graças a essas empresas fantásticas! + +### Materialize + +O banco de dados de streaming para análise em tempo real. + +[Materialize](https://materialize.com/) é um banco de dados reativo que fornece atualizações de visualização incrementais. O Materialize ajuda os desenvolvedores a construir facilmente com streaming de dados usando SQL padrão. + +### DigitalOcean + +A DigitalOcean é uma plataforma de serviços em nuvem que oferece a simplicidade que os desenvolvedores adoram e as empresas confiam para construir aplicativos de produção em escala. + +Ela fornece soluções de computação, armazenamento e rede altamente disponíveis, seguras e escaláveis ​​que ajudam os desenvolvedores a criar softwares excelentes com mais rapidez. + +Fundada em 2012 com escritórios em Nova York e Cambridge, MA, a DigitalOcean oferece preços transparentes e acessíveis, uma interface de usuário elegante e uma das maiores bibliotecas de recursos de código aberto disponíveis. + +Para obter mais informações, visite [https://www.digitalocean.com](https://www.digitalocean.com) ou siga [@digitalocean](https://twitter.com/digitalocean) no Twitter. + +Se você é novo na DigitalOcean, pode obter um crédito gratuito de $ 100 e criar seus próprios servidores através deste link de referência aqui: + +[Crédito grátis de $ 100 para a DigitalOcean](https://m.do.co/c/2a9bba940f39) + +### DevDojo + +O DevDojo é um recurso para aprender tudo sobre desenvolvimento web e web design. Aprenda na hora do almoço ou acorde e tome uma xícara de café conosco para aprender algo novo. + +Junte-se a esta comunidade de desenvolvedores e todos nós podemos aprender juntos, construir juntos e crescer juntos. + +[Junte-se ao DevDojo](https://devdojo.com?ref=bobbyiliev) + +Para obter mais informações, visite [https://www.devdojo.com](https://www.devdojo.com?ref=bobbyiliev) ou siga [@thedevdojo](https://twitter.com/thedevdojo) em Twitter. + +## Ferramenta de geração de PDF + +Este e-book foi gerado por [Ibis](https://github.com/themsaid/ibis/) desenvolvido por [Mohamed Said](https://github.com/themsaid). + +Ibis é uma ferramenta PHP que ajuda você a escrever eBooks em markdown. + +## Ferramenta de geração de ePub + +A versão ePub foi gerada por [Pandoc](https://pandoc.org/). + +## Capa do Livro + +A capa deste ebook foi criada com o [Canva.com](https://www.canva.com/join/determined-cork-learn). + +Se você precisar criar um gráfico, pôster, convite, logotipo, apresentação – ou qualquer coisa que pareça boa – experimente o Canva. + +## Licença + +Licença MIT + +Direitos autorais (c) 2020 Bobby Iliev + +É concedida permissão, gratuitamente, a qualquer pessoa que obtenha uma cópia +deste software e arquivos de documentação associados (o "Software"), para lidar +no Software sem restrição, incluindo, sem limitação, os direitos +usar, copiar, modificar, mesclar, publicar, distribuir, sublicenciar e/ou vender +cópias do Software, e para permitir que as pessoas a quem o Software é +equipado para tal, nas seguintes condições: + +O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todos as +cópias ou partes substanciais do Software. + +O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU +IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, +ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUM CASO A +AUTORES OU DETENTORES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER REIVINDICAÇÃO, DANOS OU OUTROS +RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, +FORA OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO +PROGRAMAS. diff --git a/ebook/pt_br/content/001-introduction-to-bash.md b/ebook/pt_br/content/001-introduction-to-bash.md new file mode 100644 index 0000000..b6d8267 --- /dev/null +++ b/ebook/pt_br/content/001-introduction-to-bash.md @@ -0,0 +1,9 @@ +# Introdução ao Bash scripting + +Bem vindo a este guia de treinamento básico de Bash! Neste **curso intensivo de bash**, você aprenderá o **Bash basico**Então você pode iniciar escrevendo seus próprios scripts e automatizar suas tarefas diárias. + +Bash é um shell Unix e linguagem de comando. Está amplamente disponível em vários sistemas operacionais e também é o interpretador de comandos padrão na maioria dos sistemas Linux. + +Bash significa Bourne-Again SHell. Assim como em outros shells, você pode usar o Bash interativamente diretamente em seu terminal e também pode usar o Bash como qualquer outra linguagem de programação para escrever scripts. Este livro irá ajudá-lo a aprender os fundamentos do script Bash, incluindo Bash Variables, User Input, Comments, Arguments, Arrays, Conditional Expressions, Conditionals, Loops, Functions, Debugging e testing. + +Para escrever scripts Bash, você só precisa de um terminal UNIX e um editor de texto como Sublime Text, VS Code ou um editor baseado em terminal como vim ou nano. diff --git a/ebook/pt_br/content/002-bash-structure.md b/ebook/pt_br/content/002-bash-structure.md new file mode 100644 index 0000000..6f66440 --- /dev/null +++ b/ebook/pt_br/content/002-bash-structure.md @@ -0,0 +1,25 @@ +# Estrutura Bash + +Vamos começar criando um novo arquivo com a extensão `.sh`. Como exemplo, poderíamos criar um arquivo chamado `devdojo.sh`. + +Para criar esse arquivo, você pode usar o comando `touch`: + +```bash +touch devdojo.sh +``` + +Ou você pode usar seu editor de texto: + +```bash +nano devdojo.sh +``` + +Para executar/rodar um arquivo de script bash com o interpretador de shell bash, a primeira linha de um arquivo de script deve indicar o caminho absoluto para o executável bash: + +```bash +#!/bin/bash +``` + +Isso também é chamado de [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)). + +Tudo o que o shebang faz é instruir o sistema operacional a executar o script com o executável `/bin/bash`. diff --git a/ebook/pt_br/content/003-bash-hello-world.md b/ebook/pt_br/content/003-bash-hello-world.md new file mode 100644 index 0000000..a248690 --- /dev/null +++ b/ebook/pt_br/content/003-bash-hello-world.md @@ -0,0 +1,41 @@ +# Bash Hello World + +Uma vez que criamos nosso arquivo `devdojo.sh` e especificamos o bash shebang na primeira linha, estamos prontos para criar nosso primeiro script bash `Hello World`. + +Para fazer isso, abra o arquivo `devdojo.sh` novamente e adicione o seguinte após a linha `#!/bin/bash`: + +```bash +#!/bin/bash + +echo "Hello World!" +``` + +Salve o arquivo e saia. + +Depois disso, torne o script executável executando: + +```bash +chmod +x devdojo.sh +``` + +Após isso execute o arquivo: + +```bash +./devdojo.sh +``` + +Você verá uma mensagem "Hello World" na tela. + +Outra maneira de executar o script seria: + +```bash +bash devdojo.sh +``` + +Como o bash pode ser usado interativamente, você pode executar o seguinte comando diretamente no seu terminal e obter o mesmo resultado: + +```bash +echo "Hello DevDojo!" +``` + +Colocar em um script é útil quando você precisa combinar vários comandos. diff --git a/ebook/pt_br/content/004-bash-variables.md b/ebook/pt_br/content/004-bash-variables.md new file mode 100644 index 0000000..6035f1c --- /dev/null +++ b/ebook/pt_br/content/004-bash-variables.md @@ -0,0 +1,86 @@ +# Variáveis ​​Bash + +Como em qualquer outra linguagem de programação, você também pode usar variáveis ​​no Bash Scripting. No entanto, não há tipos de dados e uma variável no Bash pode conter números e caracteres. + +Para atribuir um valor a uma variável, tudo que você precisa fazer é usar o sinal `=`: + +```bash +name="DevDojo" +``` + +>{notice} como uma nota importante, você não pode ter espaços antes e depois do sinal `=`. + +Depois disso, para acessar a variável, você deve usar o `$` e referenciá-la conforme mostrado abaixo: + +```bash +echo $name +``` + +Colocar o nome da variável entre colchetes não é obrigatório, mas é considerado uma boa prática, e eu aconselho você a usá-los sempre que puder: + +```bash +eco ${nome} +``` + +O código acima produziria: `DevDojo` pois este é o valor da nossa variável `name`. + +Em seguida, vamos atualizar nosso script `devdojo.sh` e incluir uma variável nele. + +Novamente, você pode abrir o arquivo `devdojo.sh` com seu editor de texto favorito, estou usando o nano aqui para abrir o arquivo: + +```bash +nano devdojo.sh +``` + +Adicionando nossa variável `name` no arquivo, com uma mensagem de boas vindas. Nosso arquivo agora está assim: + +```bash +#!/bin/bash + +name="DevDojo" + +echo "Hello $nome" +``` + +Salve-o e execute o arquivo usando o comando abaixo: + +```bash +./devdojo.sh +``` + +Você veria a seguinte saída na tela: + +```bash +Hello DevDojo +``` + +Aqui está um resumo do script escrito no arquivo: + +* `#!/bin/bash` - Inicialmente, especificamos nosso shebang. +* `name=DevDojo` - Em seguida, definimos uma variável chamada `name` e atribuímos um valor a ela. +* `echo "Hi there $name"` - Finalmente, nós mostramos o conteúdo da variável na tela como uma mensagem de boas-vindas usando `echo` + +Você também pode adicionar várias variáveis ​​no arquivo, conforme mostrado abaixo: + +```bash +#!/bin/bash + +name="DevDojo" +greeting="Hello" + +echo "$greeting $name" +``` + +Salve o arquivo e execute-o novamente: + +```bash +./devdojo.sh +``` + +Você veria a seguinte saída na tela: + +```bash +Hello DevDojo +``` + +Observe que você não precisa necessariamente adicionar ponto e vírgula `;` no final de cada linha. Funciona nos dois sentidos, um pouco como outras linguagens de programação, como JavaScript! diff --git a/ebook/pt_br/content/005-bash-user-input.md b/ebook/pt_br/content/005-bash-user-input.md new file mode 100644 index 0000000..c692a6b --- /dev/null +++ b/ebook/pt_br/content/005-bash-user-input.md @@ -0,0 +1,54 @@ +# Entrada de dados pelo no Bash + +Com o script anterior, definimos uma variável e mostramos o valor da variável na tela com o `echo $name`. + +Agora vamos em frente e pediremos ao usuário para entrar com dados. Para fazer isso novamente, abra o arquivo com seu editor de texto favorito e atualize o script da seguinte forma: + +```bash +#!/bin/bash + +echo "Qual é o seu nome?" +read name + +echo "Hello $name" +echo "Bem-vindo ao DevDojo!" +``` + +O script acima solicitará que o usuário entre com dados e, em seguida, armazenará essa entrada como uma string/texto em uma variável. + +Podemos então usar a variável e imprimir uma mensagem de volta para eles. + +A saída do script acima seria: + +* Primeiro execute o script: + +```bash +./devdojo.sh +``` + +* Em seguida, você será solicitado a inserir seu nome: + +``` +Qual o seu nome? +Bobby +``` + +* Depois de digitar seu nome, basta pressionar enter e você obterá a seguinte saída: + +``` +Hello, Bobby +Bem-vindo ao DevDojo! +``` + +Para reduzir o código, poderíamos alterar a primeira instrução `echo` com o `read -p`, o comando `read` usado com o sinalizador `-p` imprimirá uma mensagem antes de solicitar ao usuário sua entrada: + +```bash +#!/bin/bash + +leia -p "Qual é o seu nome?" name + +echo "Hello $name" +echo "Bem-vindo ao DevDojo!" +``` + +Certifique-se de testar isso você mesmo também! diff --git a/ebook/pt_br/content/006-bash-comments.md b/ebook/pt_br/content/006-bash-comments.md new file mode 100644 index 0000000..9e462b9 --- /dev/null +++ b/ebook/pt_br/content/006-bash-comments.md @@ -0,0 +1,27 @@ +# Comentários em Bash + +Como em qualquer outra linguagem de programação, você pode adicionar comentários ao seu script. Os comentários são usados para deixar notas entre seu código. + +Para fazer isso no Bash, você precisa adicionar o símbolo `#` no início da linha. Os comentários nunca serão renderizados na tela. + +Aqui está um exemplo de comentário: + +```bash +# Este é um comentário e não será renderizado na tela +``` + +Vamos em frente e adicionar alguns comentários ao nosso script: + +```bash +#!/bin/bash + +# Pergunte ao usuário seu nome + +leia -p "Qual é o seu nome?" name + +# Cumprimentar o usuário +echo "Hello $name" +echo "Bem-vindo ao DevDojo!" +``` + +Os comentários são uma ótima maneira de descrever algumas das funcionalidades mais complexas diretamente em seus scripts para que outras pessoas possam encontrar seu código com facilidade. diff --git a/ebook/pt_br/content/007-bash-arguments.md b/ebook/pt_br/content/007-bash-arguments.md new file mode 100644 index 0000000..32a775c --- /dev/null +++ b/ebook/pt_br/content/007-bash-arguments.md @@ -0,0 +1,77 @@ +# Argumentos Bash + +Você pode passar argumentos para seu script de shell ao executá-lo. Para passar um argumento, você só precisa escrevê-lo logo após o nome do seu script. Por exemplo: + +```bash +./devdojo.sh com_seu_argumento +``` + +No script, podemos usar `$1` para referenciar o primeiro argumento que especificamos. + +Se passarmos um segundo argumento, ele estará disponível como `$2` e assim por diante. + +Vamos criar um pequeno script chamado `arguments.sh` como exemplo: + +```bash +#!/bin/bash + +echo "O argumento um é $1" +echo "O argumento dois é $2" +echo "O argumento três é $3" +``` + +Salve o arquivo e torne-o executável: + +```bash +chmod +x argumentos.sh +``` + +Em seguida, execute o arquivo e passe **3** argumentos: + +```bash +./arguments.sh cachorro gato ave +``` + +A saída que você obteria seria: + +```bash +Argumento um é cachorro +Argumento dois é gato +Argumento três é ave +``` + +Para referenciar todos os argumentos, você pode usar `$@`: + +```bash +#!/bin/bash + +echo "Todos os argumentos: $@" +``` + +Se você executar o script novamente: + +```bash +./argumentos.sh cachorro gato ave +``` + +Você obterá a seguinte saída: + +``` +Todos os argumentos: cachorro gato ave +``` + +Outra coisa que você precisa ter em mente é que `$0` é usado para referenciar o próprio script. + +Esta é uma excelente maneira de criar a autodestruição do arquivo se você precisar ou apenas obter o nome do script. + +Por exemplo, vamos criar um script que imprima o nome do arquivo e exclua o arquivo depois disso: + +```bash +#!/bin/bash + +echo "O nome do arquivo é: $0 e será auto-excluído." + +rm -f $ 0 +``` + +Você precisa ter cuidado com a autoexclusão e garantir que você tenha o backup do script antes de excluí-lo automaticamente. diff --git a/ebook/pt_br/content/008-bash-arrays.md b/ebook/pt_br/content/008-bash-arrays.md new file mode 100644 index 0000000..c270dac --- /dev/null +++ b/ebook/pt_br/content/008-bash-arrays.md @@ -0,0 +1,111 @@ +# Arrays Bash + +Se você já fez alguma programação, provavelmente já está familiarizado com arrays. + +Mas caso você não seja um desenvolvedor, a principal coisa que você precisa saber é que, diferentemente das variáveis, os arrays podem conter vários valores sob um nome. + +Você pode inicializar um array atribuindo valores divididos por espaço e entre `()`. Exemplo: + +```bash +my_array=("valor 1" "valor 2" "valor 3" "valor 4") +``` + +Para acessar os elementos na matriz, você precisa referenciá-los por seu índice numérico. + +>{notice} tenha em mente que você precisa usar colchetes. + +* Acesse um único elemento, isso resultaria em: `valor 2` + +```bash +echo ${my_array[1]} +``` + +* Isso retornaria o último elemento: `valor 4` + +```bash +echo ${my_array[-1]} +``` + +* Assim como os argumentos de linha de comando, usar `@` retornará todos os argumentos na matriz, como segue: `valor 1 valor 2 valor 3 valor 4` + +```bash +echo ${my_array[@]} +``` + +* Prefixar o array com um sinal de hash (`#`) produziria o número total de elementos no array, no nosso caso é `4`: + +```bash +echo ${#my_array[@]} +``` + +Certifique-se de testar isso e praticá-lo com valores diferentes. + +## Substring no Bash :: Fatiando + +Vamos revisar o seguinte exemplo de fatiamento em uma string no Bash: + +```bash +#!/bin/bash + +letras=("A""B""C""D""E") +echo ${letras[@]} +``` + +Este comando imprimirá todos os elementos de um array. + +Resultado: + +```bash +ABCDE +``` + +Vejamos mais alguns exemplos: + +* Exemplo 1 + +```bash +#!/bin/bash + +letras=("A""B""C""D""E") +b=${letras:0:2} +echo "${b}" +``` + +Este comando imprimirá a matriz do índice inicial 0 a 2, onde 2 é exclusivo. + +```bash +AB +``` + +* Exemplo 2 + +```bash +#!/bin/bash + +letras=("A""B""C""D""E") +b=${letras::5} +echo "${b}" +``` + +Este comando imprimirá do índice base 0 a 5, onde 5 é exclusivo e o índice inicial é definido como 0 . + +```bash +ABCDE +``` + +* Exemplo 3 + +```bash +#!/bin/bash + +letras=("A""B""C""D""E") +b=${letras:3} +echo "${b}" +``` + +Este comando imprimirá a partir do índice inicial + 3 ao final do array inclusive . + + ```bash + DE + ``` diff --git a/ebook/pt_br/content/009-bash-conditional-expressions.md b/ebook/pt_br/content/009-bash-conditional-expressions.md new file mode 100644 index 0000000..bab95be --- /dev/null +++ b/ebook/pt_br/content/009-bash-conditional-expressions.md @@ -0,0 +1,186 @@ +# Expressões Condicionais Bash + +Na ciência da computação, declarações condicionais, expressões condicionais e construções condicionais são recursos de uma linguagem de programação, que executam diferentes computações ou ações dependendo se uma condição booleana especificada pelo programador é avaliada como verdadeira ou falsa. + +No Bash, as expressões condicionais são usadas pelo comando composto `[[` e os comandos internos `[` para testar os atributos do arquivo e realizar comparações aritméticas e de strings. + +Aqui está uma lista das expressões condicionais Bash mais populares. Você não precisa memorizá-los de cor. Você pode simplesmente consultar esta lista sempre que precisar! + +## Expressões de arquivo + +* Verdadeiro se o arquivo existir. + +```bash +[[ -a ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um arquivo especial de bloco. + +```bash +[[ -b ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um arquivo especial de caracteres. + +```bash +[[ -c ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um diretório. + +```bash +[[ -d ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir. + +```bash +[[ -e ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um arquivo normal. + +```bash +[[ -f ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um link simbólico. + +```bash +[[ -h ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for legível. + +```bash +[[ -r ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e tiver um tamanho maior que zero. + +```bash +[[ -s ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for gravável. + +```bash +[[ -w ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for executável. + +```bash +[[ -x ${arquivo}]] +``` + +* Verdadeiro se o arquivo existir e for um link simbólico. + +```bash +[[ -L ${arquivo}]] +``` + +## Expressões de string + +* True se a variável shell varname estiver definida (foi atribuído um valor). + +```bash +[[ -v ${varname}]] +``` + +* True se o comprimento da string for zero. + +```bash +[[ -z ${string}]] +``` + +* True se o comprimento da string for diferente de zero. + +```bash +[[ -n ${string}]] +``` + +* True se as strings forem iguais. `=` deve ser usado com o comando test para conformidade com POSIX. Quando usado com o comando `[[`, ele executa a correspondência de padrões conforme descrito acima (Comandos compostos). + +```bash +[[ ${string1} == ${string2}]] +``` + +* True se as strings não forem iguais. + +```bash +[[ ${string1} != ${string2} ]] +``` + +* Verdadeiro se string1 classificar antes de string2 lexicograficamente. + +```bash +[[ ${string1} < ${string2} ]] +``` + +* Verdadeiro se string1 classificar após string2 lexicograficamente. + +```bash +[[ ${string1} > ${string2}]] +``` + +## Operadores aritméticos + +* Retorna verdadeiro se os números forem **iguais** + +```bash +[[ ${arg1} -eq ${arg2} ]] +``` + +* Retorna verdadeiro se os números **não forem iguais** + +```bash +[[ ${arg1} -ne ${arg2} ]] +``` + +* Retorna verdadeiro se arg1 for **menor que** arg2 + +```bash +[[ ${arg1} -lt ${arg2} ]] +``` + +* Retorna verdadeiro se arg1 for **menor ou igual** arg2 + +```bash +[[ ${arg1} -le ${arg2} ]] +``` + +* Retorna verdadeiro se arg1 for **maior que** arg2 + +```bash +[[ ${arg1} -gt ${arg2} ]] +``` + +* Retorna verdadeiro se arg1 for **maior ou igual** arg2 + +```bash +[[ ${arg1} -ge ${arg2} ]] +``` + +Como uma nota lateral, arg1 e arg2 podem ser números inteiros positivos ou negativos. + +Assim como em outras linguagens de programação, você pode usar as condições `AND` e `OR`: + +```bash +[[ test_case_1 ]] && [[ test_case_2 ]] # E +[[ test_case_1 ]] || [[ test_case_2 ]] # Ou +``` + +## Operadores de status de saída + +* Retorna true se o comando foi bem sucedido sem nenhum erro + +```bash +[[$? -eq 0 ]] +``` + +* Retorna true se o comando não foi bem sucedido ou teve erros + +```bash +[[$? -gt 0 ]] +``` diff --git a/ebook/pt_br/content/010-bash-conditionals.md b/ebook/pt_br/content/010-bash-conditionals.md new file mode 100644 index 0000000..96700f2 --- /dev/null +++ b/ebook/pt_br/content/010-bash-conditionals.md @@ -0,0 +1,187 @@ +# Condicionais Bash + +Na última seção, abordamos algumas das expressões condicionais mais populares. Agora podemos usá-los com instruções condicionais padrão como instruções `if`, `if-else` e ​​`switch case`. + +## Declaração Se (if) + +O formato de uma instrução `if` no Bash é o seguinte: + +```bash +if [[ algum_teste ]] +then + +fi +``` + +Aqui está um exemplo rápido que pediria para você digitar seu nome caso você o tenha deixado em branco: + +```bash +#!/bin/bash + +# Bash if exemplo de instrução + +read -p "Qual é o seu nome?" name + +if [[ -z ${name} ]] +then + echo "Por favor, digite seu nome!" +fi +``` + +## Instrução Se Senão (If Else) + +Com uma instrução `if-else`, você pode especificar uma ação caso a condição na instrução `if` não corresponda. Podemos combinar isso com as expressões condicionais da seção anterior da seguinte forma: + +```bash +#!/bin/bash + +# Bash if exemplo de instrução + +read -p "Qual é o seu nome?" name + +if [[ -z ${name} ]] +then + echo "Por favor, digite seu nome!" +else + echo "Olá ${name}" +fi +``` + +Você pode usar a instrução if acima com todas as expressões condicionais dos capítulos anteriores: + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Digite seu nome de usuário?" nome_de_usuario + +# Verifique se o nome de usuário fornecido é o admin + +if [[ "${nome_de_usuario}" == "${admin}" ]] ; then + echo "Você é o usuário administrador!" +else + echo "Você NÃO é o usuário administrador!" +fi +``` + +Aqui está outro exemplo de uma instrução `if` que verificaria seu `User ID` atual e não permitiria que você executasse o script como o usuário `root`: + +```bash +#!/bin/bash + +if (( $EUID == 0 )); then + echo "Por favor, não execute como root" + exit +fi +``` + +Se você colocar isso no topo do seu script, ele sairá caso o EUID seja 0 e não execute o resto do script. Isso foi discutido no [fórum da comunidade DigitalOcean](https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script). + +Você também pode testar várias condições com uma instrução `if`. Neste exemplo, queremos ter certeza de que o usuário não é o usuário administrador nem o usuário root para garantir que o script seja incapaz de causar muitos danos. Usaremos o operador `or` neste exemplo, indicado por `||`. Isso significa que qualquer uma das condições precisa ser verdadeira. Se usássemos o operador `and` de `&&`, ambas as condições precisariam ser verdadeiras. + +```bash +#!/bin/bash + +admin="devdojo" + +read -p "Digite seu nome de usuário?" nome_de_usuario + +# Verifique se o nome de usuário fornecido é o admin + +if [[ "${nome_de_usuario}" != "${admin}" ]] || [[ $EUID != 0 ]] ; then + echo "Você não é o administrador ou usuário root, mas por favor, esteja seguro!" +else + echo "Você é o usuário administrador! Isso pode ser muito destrutivo!" +fi +``` + +Se você tiver várias condições e cenários, pode usar a instrução `elif` com instruções `if` e `else`. + +```bash +#!/bin/bash + +read -p "Digite um número: " num + +if [[ $num -gt 0 ]] ; then + echo "O número é positivo" +elif [[ $num -lt 0 ]] ; then + echo "O número é negativo" +else + echo "O número é 0" +fi +``` + +## Instruções Switch Case + +Como em outras linguagens de programação, você pode usar uma instrução `case` para simplificar condicionais complexas quando houver várias opções diferentes. Então, em vez de usar algumas instruções `if` e `if-else`, você pode usar uma única instrução `case`. + +A sintaxe da instrução Bash `case` se parece com isso: + +```bash +caso $alguma_variável in + + padrão_1) + comandos + ;; + + padrão_2| padrão_3) + comandos + ;; + + *) + comandos padrão + ;; +esac +``` + +Um rápido resumo da estrutura: + +* Todas as instruções `case` começam com a palavra-chave `case`. +* Da mesma forma que a palavra-chave `case`, você precisa especificar uma variável ou uma expressão seguida pela palavra-chave `in`. +* Depois disso, você tem seus padrões `case`, onde você precisa usar `)` para identificar o final do padrão. +* Você pode especificar vários padrões divididos por uma barra vertical: `|`. +* Após o padrão, você especifica os comandos que deseja que sejam executados caso o padrão corresponda à variável ou à expressão que você especificou. +* Todas as cláusulas devem ser encerradas adicionando `;;` no final. +* Você pode ter uma declaração padrão adicionando um `*` como padrão. +* Para fechar a instrução `case`, use a palavra-chave `esac` (case typed backward). + +Aqui está um exemplo de uma instrução Bash `case`: + +```bash +#!/bin/bash + +read -p "Digite o nome da marca do seu carro: " carro + +case $carro in + + Tesla) + echo -n "A fábrica de carros de ${carro} está nos EUA." + ;; + + BMW | Mercedes | Audi | Porsche) + echo -n "A fábrica de carros de ${carro} fica na Alemanha." + ;; + + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "A fábrica de carros de ${carro} está no Japão." + ;; + + *) + echo -n "${carro} é uma marca de carro desconhecida" + ;; + +esac +``` + +Com este script, pedimos ao usuário que insira o nome de uma marca de carro como Telsa, BMW, Mercedes e etc. + +Em seguida, com uma declaração `case`, verificamos o nome da marca e se corresponde a algum de nossos padrões e, em caso afirmativo, imprimimos a localização da fábrica. + +Se o nome da marca não corresponder a nenhuma de nossas declarações `case`, imprimimos uma mensagem padrão: `uma marca de carro desconhecida`. + +## Conclusão + +Aconselho você a tentar modificar o roteiro e brincar um pouco com ele para que possa praticar o que acabou de aprender nos dois últimos capítulos! + +Para mais exemplos de instruções `case` do Bash, certifique-se de verificar o capítulo 16, onde criaríamos um menu interativo no Bash usando uma instrução `cases` para processar a entrada do usuário. diff --git a/ebook/pt_br/content/011-bash-loops.md b/ebook/pt_br/content/011-bash-loops.md new file mode 100644 index 0000000..1364f48 --- /dev/null +++ b/ebook/pt_br/content/011-bash-loops.md @@ -0,0 +1,199 @@ +# Laços Bash (Loops) + +Como em qualquer outra linguagem, os loops são muito convenientes. Com o Bash você pode usar loops `for`, loops `while` e loops `until`. + +## Laços For + +Aqui está a estrutura de um loop for: + +```bash +for var in ${list} +do + seus_comandos +done +``` + +Exemplo: + +```bash +#!/bin/bash + +users="devdojo bobby tony" + +for user in ${users} +do + echo "${user}" +done +``` + +Um resumo rápido do exemplo: + +* Primeiro, especificamos uma lista de usuários e armazenamos o valor em uma variável chamada `$users`. +* Depois disso, iniciamos nosso loop `for` com a palavra-chave `for` +* Em seguida, definimos uma nova variável que representaria cada item da lista que damos. No nosso caso, definimos uma variável chamada `user`, que representaria cada usuário da variável `$users`. +* Em seguida, especificamos a palavra-chave `in` seguida por nossa lista que percorreremos +* Na próxima linha, usamos a palavra-chave `do`, que indica o que faremos para cada iteração do loop +* Em seguida, especificamos os comandos que queremos executar +* Finalmente, fechamos o loop com a palavra-chave `done` + +Você também pode usar `for` para processar uma série de números. Por exemplo, aqui está uma maneira de percorrer de 1 a 10: + +```bash +#!/bin/bash + +for num in {1..10} +do + echo ${num} +done +``` + +## Laços Enquanto (While) + +A estrutura de um loop while é bastante semelhante ao loop `for`: + +```bash +while [[sua_condição]] +do + suas_condições +done +``` + +Aqui está um exemplo de um loop `while`: + +```bash +#!/bin/bash + +contador=1 +while [[ $contador -le 10 ]] +do + echo $ contador + ((contador++)) +done +``` + +Primeiro, especificamos uma variável de contador e a definimos como `1`, então dentro do loop, adicionamos contador usando esta instrução aqui: `((contador++))`. Dessa forma, garantimos que o loop será executado apenas 10 vezes e não será executado para sempre. O loop será concluído assim que o contador se tornar 10, pois isso é o que definimos como condição: `while [[ $contador -le 10 ]]`. + +Vamos criar um script que peça o nome do usuário e não permita uma entrada vazia: + +```bash +#!/bin/bash + +read -p "Qual é o seu nome?" name + +while [[ -z ${name} ]] +do + echo "Seu nome não pode ficar em branco. Por favor, digite um nome válido!" + read -p "Digite seu nome novamente?" name +done + +echo "Olá ${name}" +``` + +Agora, se você executar o script acima e apenas pressionar enter sem fornecer dados, o loop será executado novamente e solicitará seu nome várias vezes até que você forneça algum dado. + +## Laços Até (Until) + +A diferença entre os loops `until` e `while` é que o loop `until` executará os comandos dentro do loop até que a condição se torne verdadeira. + +Estrutura: + +```bash +until [[sua_condição]] +do + seus_comandos +done +``` + +Exemplo: + +```bash +#!/bin/bash + +contagem=1 +until [[ $contagem -gt 10 ]] +do + echo $ contagem + ((contagem++)) +done +``` + +## Continuar e brecar + +Assim como em outras linguagens, você também pode usar `continue` e `break` com seus scripts bash: + +* `continue` diz ao seu script bash para parar a iteração atual do loop e iniciar a próxima iteração. + +A sintaxe da instrução continue é a seguinte: + +```bash +continue [n] +``` + +O argumento [n] é opcional e pode ser maior ou igual a 1. Quando [n] é fornecido, o n-ésimo loop delimitador é retomado. continue 1 é equivalente a continuar. + +```bash +#!/bin/bash + +for i in 1 2 3 4 5 +do + if [[ $i –eq 2 ]] + then + echo "pulando o número 2" + continue + fi + echo “I é igual a $i” +done +``` + +Também podemos usar o comando continue de maneira semelhante ao comando break para controlar vários loops. + +* `break` diz ao seu script bash para terminar o loop imediatamente. + +A sintaxe da instrução break assume a seguinte forma: + +```bash +break [n] +``` + +[n] é um argumento opcional e deve ser maior ou igual a 1. Quando [n] é fornecido, o n-ésimo loop de fechamento é encerrado. break 1 é equivalente a break. + +Exemplo: + +```bash +#!/bin/bash + +num=1 +while [[ $num –lt 10 ]] +do + if [[ $num –eq 5 ]] + then + break + fi + ((nº++)) +done +echo “Loop concluído” +``` + +Também podemos usar o comando break com vários loops. Se quisermos sair do loop de trabalho atual, seja interno ou externo, simplesmente usamos break, mas se estamos no loop interno e queremos sair do loop externo, usamos break 2. + +Exemplo: + +```bash +#!/bin/bash + +for ((a = 1; a < 10; a++)) +do + echo “loop externo: $a” + for ((b = 1; b < 100; b++)) + do + if [[ $b –gt 5 ]] + then + break 2 + fi + echo “Loop interno: $b” + done +done +``` + +O script bash começará com a=1 e passará para o loop interno e, quando atingir b=5, interromperá o loop externo. +Podemos usar apenas um break em vez de dois, para quebrar o loop interno e ver como isso afeta a saída. diff --git a/ebook/pt_br/content/012-bash-functions.md b/ebook/pt_br/content/012-bash-functions.md new file mode 100644 index 0000000..22e2faf --- /dev/null +++ b/ebook/pt_br/content/012-bash-functions.md @@ -0,0 +1,66 @@ +# Funções Bash + +As funções são uma ótima maneira de reutilizar o código. A estrutura de uma função no bash é bastante semelhante à maioria das linguagens: + +```bash +function nome_function() { + seus_comandos +} +``` + +Você também pode omitir a palavra-chave `function` no início, o que também funcionaria: + +```bash +nome_function() { + seus_comandos +} +``` + +Eu prefiro colocá-lo lá para melhor legibilidade. Mas é uma questão de preferência pessoal. + +Exemplo de um "Hello World!" função: + +```bash +#!/bin/bash + +função hello(){ + echo "Função Hello World!" +} + +hello +``` + +>{notice} Uma coisa a ter em mente é que você não deve adicionar os parênteses ao chamar a função. + +Passar argumentos para uma função funciona da mesma forma que passar argumentos para um script: + +```bash +#!/bin/bash + +function hello(){ + echo "Hello $1!" +} + +hello DevDojo +``` + +As funções devem ter comentários mencionando descrição, variáveis ​​globais, argumentos, saídas e valores retornados, se aplicável + +```bash +###################################### +# Descrição: Função Hello +# Globais: +# Nenhum +# Argumentos: +# Argumento de entrada único +# Saídas: +# Valor do argumento de entrada +# Retorna: +# 0 se for bem-sucedido, diferente de zero em caso de erro. +###################################### +function hello(){ + echo "Hello $1!" +} +``` + +Nos próximos capítulos, usaremos muito as funções! diff --git a/ebook/pt_br/content/013-debugging-and-testing.md b/ebook/pt_br/content/013-debugging-and-testing.md new file mode 100644 index 0000000..74be943 --- /dev/null +++ b/ebook/pt_br/content/013-debugging-and-testing.md @@ -0,0 +1,83 @@ +# Depuração, teste e atalhos + +Para depurar seus scripts bash, você pode usar `-x` ao executar seus scripts: + +```bash +bash -x ./seu_script.sh +``` + +Ou você pode adicionar `set -x` antes da linha específica que você deseja depurar, `set -x` habilita um modo do shell onde todos os comandos executados são impressos no terminal. + +Outra maneira de testar seus scripts é usar esta ferramenta fantástica aqui: + +[https://www.shellcheck.net/](https://www.shellcheck.net/) + +Basta copiar e colar seu código na caixa de texto, e a ferramenta lhe dará algumas sugestões sobre como você pode melhorar seu script. + +Você também pode executar a ferramenta diretamente no seu terminal: + +[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck) + +Se você gostar da ferramenta, certifique-se de marcá-la no GitHub e contribuir! + +Como SysAdmin/DevOps, passo muito do meu dia no terminal. Aqui estão meus atalhos favoritos que me ajudam a fazer tarefas mais rapidamente enquanto escrevo scripts Bash ou apenas enquanto trabalho no terminal. + +Os dois abaixo são particularmente úteis se você tiver um comando muito longo. + +* Exclua tudo do cursor até o final da linha: + +``` +Ctrl + k +``` + +* Exclua tudo do cursor até o início da linha: + +``` +Ctrl + você +``` + +* Excluir uma palavra para trás do cursor: + +``` +Ctrl + w +``` + +* Pesquise seu histórico para trás. Este é provavelmente o que eu mais uso. É realmente útil e acelera muito meu fluxo de trabalho: + +``` +Ctrl + r +``` + +* Limpe a tela, eu uso isso em vez de digitar o comando `clear`: + +``` +Ctrl + l +``` + +* Interrompe a saída para a tela: + +``` +Ctrl + s +``` + +* Habilite a saída para a tela caso tenha parado anteriormente por `Ctrl + s`: + +``` +Ctrl + q +``` + +* Termina o comando atual + +``` +Ctrl + c +``` + +* Jogue o comando atual em segundo plano: + +``` +Ctrl + z +``` + +Eu os uso regularmente todos os dias, e isso me economiza muito tempo. + +Se você acha que eu perdi algum, sinta-se à vontade para participar da discussão no [fórum da comunidade DigitalOcean](https://www.digitalocean.com/community/questions/what-are-your-favorite-bash-shortcuts)! diff --git a/ebook/pt_br/content/014-creating-custom-bash-commands.md b/ebook/pt_br/content/014-creating-custom-bash-commands.md new file mode 100644 index 0000000..92ea506 --- /dev/null +++ b/ebook/pt_br/content/014-creating-custom-bash-commands.md @@ -0,0 +1,85 @@ +# Criando comandos bash personalizados + +Como desenvolvedor ou administrador do sistema, você pode ter que passar muito tempo em seu terminal. Eu sempre tento procurar maneiras de otimizar quaisquer tarefas repetitivas. + +Uma maneira de fazer isso é escrever scripts bash curtos ou criar comandos personalizados também conhecidos como aliases. Por exemplo, em vez de digitar um comando muito longo toda vez, você pode simplesmente criar um atalho para ele. + +## Exemplo + +Vamos começar com o seguinte cenário, como administrador do sistema, você pode ter que verificar as conexões com seu servidor web com bastante frequência, então usarei o comando `netstat` como exemplo. + +O que eu normalmente faço quando acesso um servidor que está tendo problemas com as conexões à porta 80 ou 443 é verificar se há algum serviço escutando nessas portas e o número de conexões nas portas. + +O seguinte comando `netstat` nos mostraria quantas conexões TCP nas portas 80 e 443 temos atualmente: + +```bash +netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l +``` + +Este é um comando bastante longo, portanto, digitá-lo sempre pode ser demorado a longo prazo, especialmente quando você deseja obter essas informações rapidamente. + +Para evitar isso, podemos criar um alias, então, em vez de digitar o comando inteiro, podemos simplesmente digitar um comando curto. Por exemplo, digamos que queríamos poder digitar `conn` (abreviação de conexões) e obter as mesmas informações. Tudo o que precisamos fazer neste caso é executar o seguinte comando: + +```bash +alias conn="netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Dessa forma, estamos criando um alias chamado `conn` que seria essencialmente um 'atalho' para nosso longo comando `netstat`. Agora, se você executar apenas `conn`: + +```bash +conn +``` + +Você obteria a mesma saída que o comando longo `netstat`. +Você pode ser ainda mais criativo e adicionar algumas mensagens informativas como esta aqui: + +```bash +alias conn="echo 'Total de conexões na porta 80 e 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Agora, se você executar `conn`, obterá a seguinte saída: + +```bash +Total de conexões na porta 80 e 443: +12 +``` + +Agora, se você sair e entrar novamente, seu alias será perdido. Na próxima etapa, você verá como tornar isso persistente. + +## Tornando a mudança persistente + +Para tornar a alteração persistente, precisamos adicionar o comando `alias` em nosso arquivo de perfil do shell. + +Por padrão no Ubuntu este seria o arquivo `~/.bashrc`, para outros sistemas operacionais pode ser o arquivo `~/.bash_profle`. Com seu editor de texto favorito abra o arquivo: + +```bash +nano ~/.bashrc +``` + +Vá para a parte inferior e adicione o seguinte: + +```bash +alias conn="echo 'Total de conexões na porta 80 e 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Salve e depois saia. + +Dessa forma, agora, mesmo que você faça logout e faça login novamente, sua alteração persistirá e você poderá executar seu comando bash personalizado. + +## Listando todos os aliases disponíveis + +Para listar todos os aliases disponíveis para seu shell atual, basta executar o seguinte comando: + +```bash +alias +``` + +Isso seria útil caso você esteja vendo algum comportamento estranho com alguns comandos. + +## Conclusão + +Essa é uma maneira de criar comandos bash personalizados ou aliases bash. + +Claro, você poderia realmente escrever um script bash e adicionar o script dentro de sua pasta `/usr/bin`, mas isso não funcionaria se você não tivesse acesso root ou sudo, enquanto com aliases você pode fazer isso sem a necessidade de acesso root. + +>{notice} Isso foi postado inicialmente em [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-create-custom-bash-commands) diff --git a/ebook/pt_br/content/015-writing-your-first-bash-script.md b/ebook/pt_br/content/015-writing-your-first-bash-script.md new file mode 100644 index 0000000..f603e30 --- /dev/null +++ b/ebook/pt_br/content/015-writing-your-first-bash-script.md @@ -0,0 +1,180 @@ +# Escreva seu primeiro script Bash + +Vamos tentar juntar o que aprendemos até agora e criar nosso primeiro script Bash! + +## Planejando o roteiro + +Como exemplo, escreveremos um script que reuniria algumas informações úteis sobre nosso servidor, como: + +* Uso atual do disco +* Uso atual da CPU +* Uso atual de RAM +* Verifique a versão exata do Kernel + +Sinta-se à vontade para ajustar o script adicionando ou removendo a funcionalidade para que corresponda às suas necessidades. + +## Escrevendo o roteiro + +A primeira coisa que você precisa fazer é criar um novo arquivo com a extensão `.sh`. Vou criar um arquivo chamado `status.sh` pois o script que vamos criar nos daria o status do nosso servidor. + +Depois de criar o arquivo, abra-o com seu editor de texto favorito. + +Como aprendemos no capítulo 1, na primeira linha do nosso script Bash, precisamos especificar o chamado [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)): + +```bash +#!/bin/bash +``` + +Tudo o que o shebang faz é instruir o sistema operacional a executar o script com o executável /bin/bash. + +## Adicionando comentários + +Em seguida, conforme discutido no capítulo 6, vamos começar adicionando alguns comentários para que as pessoas possam descobrir facilmente para que serve o script. Para fazer isso logo após o shebang, basta adicionar o seguinte: + +```bash +#!/bin/bash + +# Script que retorna o status atual do servidor +``` + +## Adicionando sua primeira variável + +Então vamos aplicar o que aprendemos no capítulo 4 e adicionar algumas variáveis ​​que podemos querer usar em todo o script. + +Para atribuir um valor a uma variável no bash, você só precisa usar o sinal `=`. Por exemplo, vamos armazenar o hostname do nosso servidor em uma variável para que possamos usá-lo mais tarde: + +```bash +server_name=$(hostname) +``` + +Usando `$()` dizemos ao bash para interpretar o comando e então atribuir o valor à nossa variável. + +Agora, se ecoássemos a variável, veríamos o nome do host atual: + +```bash +echo $server_name +``` + +## Adicionando sua primeira função + +Como você já sabe depois de ler o capítulo 12, para criar uma função no bash você precisa usar a seguinte estrutura: + +```bash +function nome_função() { + seus_comandos +} +``` + +Vamos criar uma função que retorne o uso atual de memória em nosso servidor: + +```bash +function memory_check() { + echo "" + echo "O uso atual de memória em ${server_name} é: " + free -h + echo "" +} +``` + +Resumo rápido da função: + +* `function memory_check() {` - é assim que definimos a função +* `echo ""` - aqui apenas imprimimos uma nova linha +* `echo "O uso atual de memória em ${server_name} é: "` - aqui nós imprimimos uma pequena mensagem e a variável `$server_name` +* `}` - finalmente é assim que fechamos a função + +Então, uma vez definida a função, para chamá-la, basta usar o nome da função: + +```bash +#Defina a função +function memory_check() { + echo "" + echo "O uso atual de memória em ${server_name} é: " + free -h + echo "" +} + +# Chama a função +memory_check +``` + +## Desafio de adicionar mais funções + +Antes de verificar a solução, eu desafio você a usar a função acima e escrever algumas funções por conta própria. + +As funções devem fazer o seguinte: + +* Uso atual do disco +* Uso atual da CPU +* Uso atual de RAM +* Verifique a versão exata do Kernel + +Sinta-se à vontade para usar o google se não tiver certeza de quais comandos precisa usar para obter essas informações. + +Quando estiver pronto, sinta-se à vontade para rolar para baixo e verificar como fizemos isso e comparar os resultados! + +Observe que existem várias maneiras corretas de fazer isso! + +## O script de exemplo + +Veja como ficaria o resultado final: + +```bash +#!/bin/bash + +## +# script BASH que verifica: +# - Uso de memória +# - carga da CPU +# - Número de conexões TCP +# - Versão do kernel +## + +server_name=$(hostname) + +function memory_check() { + echo "" + echo "O uso de memória em ${server_name} é: " + free -h + echo "" +} + +function cpu_check() { + echo "" + echo "A carga da CPU em ${server_name} é: " + echo "" + uptime + echo "" +} + +function tcp_check() { + echo "" + echo "Conexões TCP em ${server_name}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function kernel_check() { + echo "" + echo "A versão do kernel em ${server_name} é: " + echo "" + uname -r + echo "" +} + +function all_checks() { + memory_check + cpu_check + tcp_check + kernel_check +} + +all_checks +``` + +## Conclusão + +O script Bash é incrível! Não importa se você é um engenheiro de DevOps/SysOps, desenvolvedor ou apenas um entusiasta do Linux, você pode usar scripts Bash para combinar diferentes comandos do Linux e automatizar tarefas diárias chatas e repetitivas, para que você possa se concentrar em coisas mais produtivas e divertidas! + +>{notice} Isso foi postado inicialmente em [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) diff --git a/ebook/pt_br/content/016-creating-an-interactive-menu-in-bash.md b/ebook/pt_br/content/016-creating-an-interactive-menu-in-bash.md new file mode 100644 index 0000000..71c00fa --- /dev/null +++ b/ebook/pt_br/content/016-creating-an-interactive-menu-in-bash.md @@ -0,0 +1,305 @@ +# Criando um menu interativo no Bash + +Neste tutorial, mostrarei como criar um menu de múltipla escolha no Bash para que seus usuários possam escolher entre qual ação deve ser executada! + +Nós reutilizaríamos parte do código do capítulo anterior, portanto, se você ainda não o leu, certifique-se de fazê-lo. + +## Planejando a funcionalidade + +Vamos começar de novo analisando a funcionalidade principal do script: + +* Verifica o uso atual do disco +* Verifica o uso atual da CPU +* Verifica o uso atual da RAM +* Verifica a versão exata do Kernel + +Caso você não o tenha em mãos, aqui está o script em si: + +```bash +#!/bin/bash + +## +# Script de menu BASH que verifica: +# - Uso de memória +# - carga da CPU +# - Número de conexões TCP +# - Versão do kernel +## + +server_name=$(hostname) + +function memory_check() { + echo "" + echo "O uso de memória em ${server_name} é: " + free -h + echo "" +} + +function cpu_check() { + echo "" + echo "A carga da CPU em ${server_name} é: " + echo "" + uptime + echo "" +} + +function tcp_check() { + echo "" + echo "Conexões TCP em ${server_name}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function kernel_check() { + echo "" + echo "A versão do kernel em ${server_name} é: " + echo "" + uname -r + echo "" +} + +function all_checks() { + memory_check + cpu_check + tcp_check + kernel_check +} +``` + +Construiremos então um menu que permite ao usuário escolher qual função será executada. + +Claro, você pode ajustar a função ou adicionar novas, dependendo de suas necessidades. + +## Adicionando algumas cores + +Para tornar o menu um pouco mais 'legível' e fácil de entender à primeira vista, adicionaremos algumas funções de cores. + +No início do seu script, adicione as seguintes funções de cores: + +```bash +## +# Variáveis ​​de cor +## +verde='\e[32m' +azul='\e[34m' +clear='\e[0m' + +## +#Funções de cores +## + +CorVerde(){ + echo -ne $verde$1$clear +} +CorAzul(){ + echo -ne $azul$1$clear +} +``` + +Você pode usar as funções de cor da seguinte forma: + +```bash +echo -ne $(ColAzul 'Algum texto aqui') +``` + +O texto acima produziria a string `Algum texto aqui` e seria azul! + +# Adicionando o Menu + +Por fim, para adicionar nosso menu, criaremos uma função separada com um case switch para nossas opções de menu: + +```bash +menu(){ +echo -ne" +Meu primeiro Menu +$(CorVerde '1)') Uso de memória +$(CorVerde '2)') Carga da CPU +$(CorVerde '3)') Número de conexões TCP +$(CorVerde '4)') Versão do kernel +$(CorVerde '5)') Verificar tudo +$(CorVerde '0)') Sair +$(CorAzul 'Escolha uma opção:') " + read a + case $a in + 1) memory_check ; menu ;; + 2) cpu_check ; menu ;; + 3) tcp_check ; menu ;; + 4) kernel_check ; menu ;; + 5) all_checks ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opção errada."$clear; Comando Errado;; + esac +} +``` + +### Um rápido resumo do código + +Primeiro, apenas ecoamos as opções do menu com alguma cor: + +``` +echo -ne" +Meu primeiro Menu +$(CorVerde '1)') Uso de memória +$(CorVerde '2)') Carga da CPU +$(CorVerde '3)') Número de conexões TCP +$(CorVerde '4)') Versão do kernel +$(CorVerde '5)') Verificar tudo +$(CorVerde '0)') Sair +$(CorAzul 'Escolha uma opção:') " +``` + +Então lemos a resposta do usuário e a armazenamos em uma variável chamada `$a`: + +```bash + read a +``` + +Finalmente, temos um switch case que aciona uma função diferente dependendo do valor de `$a`: + +```bash + case $a in + 1) memory_check ; menu ;; + 2) cpu_check ; menu ;; + 3) tcp_check ; menu ;; + 4) kernel_check ; menu ;; + 5) all_checks ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opção errada."$clear; Comando Errado;; + esac +``` + +No final, precisamos chamar a função menu para realmente imprimir o menu: + +```bash +# Chama a função de menu +menu +``` + +## Testando o script + +No final, seu script ficará assim: + +```bash +#!/bin/bash + +## +# Script de menu BASH que verifica: +# - Uso de memória +# - Carga da CPU +# - Número de conexões TCP +# - Versão do kernel +## + +server_name=$(hostname) + +function memory_check() { + echo "" + echo "O uso de memória em ${server_name} é: " + free -h + echo "" +} + +function cpu_check() { + echo "" + echo "A carga da CPU em ${server_name} é: " + echo "" + uptime + echo "" +} + +function tcp_check() { + echo "" + echo "Conexões TCP em ${server_name}: " + echo "" + cat /proc/net/tcp | wc -l + echo "" +} + +function kernel_check() { + echo "" + echo "A versão do kernel em ${server_name} é: " + echo "" + uname -r + echo "" +} + +function all_checks() { + memory_check + cpu_check + tcp_check + kernel_check +} + +## +# Variáveis ​​de cor +## +verde='\e[32m' +azul='\e[34m' +clear='\e[0m' + +## +#Funções de cores +## + +CorVerde(){ + echo -ne $verde$1$clear +} +CorAzul(){ + echo -ne $azul$1$clear +} + +menu(){ +echo -ne" +Meu primeiro Menu +$(CorVerde '1)') Uso de memória +$(CorVerde '2)') Carga da CPU +$(CorVerde '3)') Número de conexões TCP +$(CorVerde '4)') Versão do kernel +$(CorVerde '5)') Verificar tudo +$(CorVerde '0)') Sair +$(CorAzul 'Escolha uma opção:') " + read a + case $a in + 1) memory_check ; menu ;; + 2) cpu_check ; menu ;; + 3) tcp_check ; menu ;; + 4) kernel_check ; menu ;; + 5) all_checks ; menu ;; + 0) exit 0 ;; + *) echo -e $red"Opção errada."$clear; Comando Errado;; + esac +} + +# Call the menu function +menu +``` + +Para testar o script, crie um novo arquivo com a extensão `.sh`, por exemplo: `menu.sh` e execute-o: + +```bash +bash menu.sh +``` + +A saída que você obterá será assim: + +```bash +Meu primeiro cardápio +1) Uso de memória +2) Carga da CPU +3) Número de conexões TCP +4) Versão do kernel +5) Verifique tudo +0) Sair +Escolha uma opção: +``` + +Você poderá escolher uma opção diferente da lista e cada número chamará uma função diferente do script: + +![Menu interativo Nice Bash](https://imgur.com/8EgxX4m.png) + +## Conclusão + +Agora você sabe como criar um menu Bash e implementá-lo em seus scripts para que os usuários possam selecionar valores diferentes! + +>{notice} Este conteúdo foi postado inicialmente em [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) diff --git a/ebook/pt_br/content/017-executing-bash-script-on-multiple-remote-server.md b/ebook/pt_br/content/017-executing-bash-script-on-multiple-remote-server.md new file mode 100644 index 0000000..74634b1 --- /dev/null +++ b/ebook/pt_br/content/017-executing-bash-script-on-multiple-remote-server.md @@ -0,0 +1,129 @@ +# Executing BASH scripts on Multiple Remote Servers + +Any command that you can run from the command line can be used in a bash script. Scripts are used to run a series of commands. Bash is available by default on Linux and macOS operating systems. + +Let's have a hypothetical scenario where you need to execute a BASH script on multiple remote servers, but you don't want to manually copy the script to each server, then again login to each server individually and only then execute the script. + +Of course you could use a tool like Ansible but lets learn how to do that with Bash! + +## Prerequisites + +For this example I will use 3 remote Ubuntu servers deployed on DigitalOcean. If you don't have a Digital Ocean account yet, you can sign up for DigitalOcean and get $100 free credit via this referral link here: + +[https://m.do.co/c/2a9bba940f39](https://m.do.co/c/2a9bba940f39) + +Once you have your Digital Ocean account ready go ahead and deploy 3 droplets. + +I've gone ahead and created 3 Ubuntu servers: + +![DigitalOcean Ubuntu servers](https://imgur.com/09xmq41.png) + +I'll put a those servers IP's in a `servers.txt` file which I would use to loop though with our Bash script. + +If you are new to DigitalOcean you can follow the steps on how to create a Droplet here: + +* [How to Create a Droplet from the DigitalOcean Control Panel](https://www.digitalocean.com/docs/droplets/how-to/create/) + +You can also follow the steps from this video here on how to do your initial server setul: + +* [How to do your Initial Server Setup with Ubuntu](https://youtu.be/7NL2_4HIgKU) + +Or even better, you can follow this article here on how to automate your initial server setup with Bash: + +[Automating Initial Server Setup with Ubuntu 18.04 with Bash](https://www.digitalocean.com/community/tutorials/automating-initial-server-setup-with-ubuntu-18-04) + +With the 3 new servers in place, we can go ahead and focus on running our Bash script on all of them with a single command! + +## The BASH Script + +I will reuse the demo script from the previous chapter with some slight changes. It simply executes a few checks like the current memory usage, the current CPU usage, the number of TCP connections and the version of the kernel. + +```bash +#!/bin/bash + +## +# BASH script that checks the following: +# - Memory usage +# - CPU load +# - Number of TCP connections +# - Kernel version +## + +## +# Memory check +## +server_name=$(hostname) + +function memory_check() { + echo "#######" + echo "The current memory usage on ${server_name} is: " + free -h + echo "#######" +} + + +function cpu_check() { + echo "#######" + echo "The current CPU load on ${server_name} is: " + echo "" + uptime + echo "#######" +} + +function tcp_check() { + echo "#######" + echo "Total TCP connections on ${server_name}: " + echo "" + cat /proc/net/tcp | wc -l + echo "#######" +} + +function kernel_check() { + echo "#######" + echo "The exact Kernel version on ${server_name} is: " + echo "" + uname -r + echo "#######" +} + +function all_checks() { + memory_check + cpu_check + tcp_check + kernel_check +} + +all_checks +``` + +Copy the code bellow and add this in a file called `remote_check.sh`. You can also get the script from [here](https://devdojo.com/bobbyiliev/executing-bash-script-on-multiple-remote-server). + +## Running the Script on all Servers + +Now that we have the script and the servers ready and that we've added those servers in our servers.txt file we can run the following command to loop though all servers and execute the script remotely without having to copy the script to each server and individually connect to each server. + +```bash +for server in $(cat servers.txt) ; do ssh your_user@${server} 'bash -s' < ./remote_check.sh ; done +``` + +What this for loop does is, it goes through each server in the servers.txt file and then it runs the following command for each item in the list: + +```bash +ssh your_user@the_server_ip 'bash -s' < ./remote_check.sh +``` + +You would get the following output: + +![Running bash script on multiple remote servers](https://imgur.com/B1AmhUP.png) + +## Conclusion + +This is just a really simple example on how to execute a simple script on multiple servers without having to copy the script to each server and without having to access the servers individually. + +Of course you could run a much more complex script and on many more servers. + +If you are interested in automation, I would recommend checking out the Ansible resources page on the DigitalOcean website: + +[Ansible Resources](https://www.digitalocean.com/community/tags/ansible) + +>{notice} This content was initially posted on [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) \ No newline at end of file diff --git a/ebook/pt_br/content/018-working-with-json-in-bash-using-jq.md b/ebook/pt_br/content/018-working-with-json-in-bash-using-jq.md new file mode 100644 index 0000000..5f057e5 --- /dev/null +++ b/ebook/pt_br/content/018-working-with-json-in-bash-using-jq.md @@ -0,0 +1,225 @@ +# Work with JSON in BASH using jq + +The `jq` command-line tool is is a lightweight and flexible command-line **JSON** processor. It is great for parsing JSON output in BASH. + +One of the great things about `jq` is that it is written in portable C, and it has zero runtime dependencies. All you need to do is to download a single binary or use a package manager like apt and install it with a single command. + +## Planning the script + +For the demo in this tutorial, I would use an external REST API that returns a simple JSON ouput called the [QuizAPI](https://quizapi.io/): + +> [https://quizapi.io/](https://quizapi.io/) + +If you want to follow along make sure to get a free API key here: + +> [https://quizapi.io/clientarea/settings/token](https://quizapi.io/clientarea/settings/token) + +The QuizAPI is free for developers. + +## Installing jq + +There are many ways to install `jq` on your system. One of the most straight forward ways to do so is to use the package manager depending on your OS. + +Here is a list of the commands that you would need to use depending on your OS: + +* Install jq on Ubuntu/Debian: + +```bash +sudo apt-get install jq +``` + +* Install jq on Fedora: + +```bash +sudo dnf install jq +``` + +* Install jq on openSUSE: + +```bash +sudo zypper install jq +``` + +- Install jq on Arch: + +```bash +sudo pacman -S jq +``` + +* Installing on Mac with Homebrew: + +```bash +brew install jq +``` + +* Install on Mac with MacPort: + +```bash +port install jq +``` + +If you are using other OS, I would recommend taking a look at the official documentation here for more information: + +> [https://stedolan.github.io/jq/download/](https://stedolan.github.io/jq/download/) + +Once you have jq installed you can check your current version by running this command: + +```bash +jq --version +``` + +## Parsing JSON with jq + +Once you have `jq` installed and your QuizAPI API Key, you can parse the JSON output of the QuizAPI directly in your terminal. + +First, create a variable that stores your API Key: + +```bash +API_KEY=YOUR_API_KEY_HERE +``` + +In order to get some output from one of the endpoints of the QuizAPI you can use the curl command: + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" +``` + +For a more specific output, you can use the QuizAPI URL Generator here: + +> [https://quizapi.io/api-config](https://quizapi.io/api-config) + +After running the curl command, the output which you would get would look like this: + +![Raw Json output](https://imgur.com/KghOfzj.png) + +This could be quite hard to read, but thanks to the jq command-line tool, all we need to do is pipe the curl command to jq and we would see a nice formated JSON output: + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq +``` + +> Note the `| jq` at the end. + +In this case the output that you would get would look something like this: + +![bash jq formatting](https://imgur.com/ebdTtVf.png) + +Now, this looks much nicer! The jq command-line tool formatted the output for us and added some nice coloring! + +## Getting the first element with jq + +Let's say that we only wanted to get the first element from the JSON output, in order to do that we have to just specify the index that we want to see with the following syntax: + +```bash +jq .[0] +``` + +Now, if we run the curl command again and pipe the output to jq .[0] like this: + +```bash +curl "https://quizapi.io/api/v1/questions?apiKey=${API_KEY}&limit=10" | jq.[0] +``` + +You will only get the first element and the output will look like this: + +![jq get first element only](https://imgur.com/h9bFMAL.png) + +## Getting a value only for specific key + +Sometimes you might want to get only the value of a specific key only, let's say in our example the QuizAPI returns a list of questions along with the answers, description and etc. but what if you wanted to get the Questions only without the additional information? + +This is going to be quite straight forward with `jq`, all you need to do is add the key after jq command, so it would look something like this: + +```bash +jq .[].question +``` + +We have to add the `.[]` as the QuizAPI returns an array and by specifying `.[]` we tell jq that we want to get the .question value for all of the elements in the array. + +The output that you would get would look like this: + +![jq get a value only for specific key](https://imgur.com/0701wHD.png) + +As you can see we now only get the questions without the rest of the values. + +## Using jq in a BASH script + +Let's go ahead and create a small bash script which should output the following information for us: + +* Get only the first question from the output +* Get all of the answers for that question +* Assign the answers to variables +* Print the question and the answers +* To do that I've put together the following script: + +>{notice} make sure to change the API_KEY part with your actual QuizAPI key: + +```bash +#!/bin/bash + +## +# Make an API call to QuizAPI and store the output in a variable +## +output=$(curl 'https://quizapi.io/api/v1/questions?apiKey=API_KEY&limit=10' 2>/dev/null) + +## +# Get only the first question +## +output=$(echo $output | jq .[0]) + +## +# Get the question +## +question=$(echo $output | jq .question) + +## +# Get the answers +## + +answer_a=$(echo $output | jq .answers.answer_a) +answer_b=$(echo $output | jq .answers.answer_b) +answer_c=$(echo $output | jq .answers.answer_c) +answer_d=$(echo $output | jq .answers.answer_d) + +## +# Output the question +## + +echo " +Question: ${question} + +A) ${answer_a} +B) ${answer_b} +C) ${answer_c} +D) ${answer_d} + +" +``` + +If you run the script you would get the following output: + +![Using jq in a bash script](https://imgur.com/LKEsrbq.png) + +We can even go further by making this interactive so that we could actually choose the answer directly in our terminal. + +There is already a bash script that does this by using the QuizAPI and `jq`: + +You can take a look at that script here: + +* [https://github.com/QuizApi/QuizAPI-BASH/blob/master/quiz.sh](https://github.com/QuizApi/QuizAPI-BASH/blob/master/quiz.sh) + +## Conclusion + +The `jq` command-line tool is an amazing tool that gives you the power to work with JSON directly in your BASH terminal. + +That way you can easily interact with all kinds of different REST APIs with BASH. + +For more information, you could take a look at the official documentation here: + +* [https://stedolan.github.io/jq/manual/](https://stedolan.github.io/jq/manual/) + +And for more information on the **QuizAPI**, you could take a look at the official documentation here: + +* [https://quizapi.io/docs/1.0/overview](https://quizapi.io/docs/1.0/overview) + +>{notice} This content was initially posted on [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-work-with-json-in-bash-using-jq) \ No newline at end of file diff --git a/ebook/pt_br/content/019-working-with-cloudflare-api-with-bash.md b/ebook/pt_br/content/019-working-with-cloudflare-api-with-bash.md new file mode 100644 index 0000000..9b66ad3 --- /dev/null +++ b/ebook/pt_br/content/019-working-with-cloudflare-api-with-bash.md @@ -0,0 +1,104 @@ +# Working with Cloudflare API with Bash + +I host all of my websites on **DigitalOcean** Droplets and I also use Cloudflare as my CDN provider. One of the benefits of using Cloudflare is that it reduces the overall traffic to your user and also hides your actual server IP address behind their CDN. + +My personal favorite Cloudflare feature is their free DDoS protection. It has saved my servers multiple times from different DDoS attacks. They have a cool API that you could use to enable and disable their DDoS protection easily. + +This chapter is going to be an exercise! I challenge you to go ahead and write a short bash script that would enable and disable the Cloudflare DDoS protection for your server automatically if needed! + +## Prerequisites + +Before following this guide here, please set up your Cloudflare account and get your website ready. If you are not sure how to do that you can follow these steps here: [Create a Cloudflare account and add a website](https://support.cloudflare.com/hc/en-us/articles/201720164-Step-2-Create-a-Cloudflare-account-and-add-a-website). + +Once you have your Cloudflare account, make sure to obtain the following information: + +* A Cloudflare account +* Cloudflare API key +* Cloudflare Zone ID + +Also, Make sure curl is installed on your server: + +```bash +curl --version +``` + +If curl is not installed you need to run the following: + +* For RedHat/CentOs: + +```bash +yum install curl +``` + +* For Debian/Ubuntu + +```bash +apt-get install curl +``` + +## Challenge - Script requirements + +The script needs to monitor the CPU usage on your server and if the CPU usage gets high based on the number vCPU it would enable the Cloudflare DDoS protection automatically via the Cloudflare API. + +The main features of the script should be: + +* Checks the script CPU load on the server +* In case of a CPU spike the script triggers an API call to Cloudflare and enables the DDoS protection feature for the specified zone +* After the CPU load is back to normal the script would disable the "I'm under attack" option and set it back to normal + +## Example script + +I already have prepared a demo script which you could use as a reference. But I encourage you to try and write the script yourself first and only then take a look at my script! + +To download the script just run the following command: + +```bash +wget https://raw.githubusercontent.com/bobbyiliev/cloudflare-ddos-protection/main/protection.sh +``` + +Open the script with your favorite text editor: + +```bash +nano protection.sh +``` + +And update the following details with your Cloudflare details: + +```bash +CF_CONE_ID=YOUR_CF_ZONE_ID +CF_EMAIL_ADDRESS=YOUR_CF_EMAIL_ADDRESS +CF_API_KEY=YOUR_CF_API_KEY +``` + +After that make the script executable: + +```bash +chmod +x ~/protection.sh +``` + +Finally, set up 2 Cron jobs to run every 30 seconds. To edit your crontab run: + +```bash +crontab -e +``` + +And add the following content: + +```bash +* * * * * /path-to-the-script/cloudflare/protection.sh +* * * * * ( sleep 30 ; /path-to-the-script/cloudflare/protection.sh ) +``` + +Note that you need to change the path to the script with the actual path where you've stored the script at. + +## Conclusion + +This is quite straight forward and budget solution, one of the downsides of the script is that if your server gets unresponsive due to an attack, the script might not be triggered at all. + +Of course, a better approach would be to use a monitoring system like Nagios and based on the statistics from the monitoring system then you can trigger the script, but this script challenge could be a good learning experience! + +Here is another great resource on how to use the Discord API and send notifications to your Discord Channel with a Bash script: + +[How To Use Discord Webhooks to Get Notifications for Your Website Status on Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-use-discord-webhooks-to-get-notifications-for-your-website-status-on-ubuntu-18-04) + +>{notice} This content was initially posted on [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-automatically-enable-cloudflare-ddos-protection) diff --git a/ebook/pt_br/content/020-nginx-and-apache-log-parser.md b/ebook/pt_br/content/020-nginx-and-apache-log-parser.md new file mode 100644 index 0000000..22bc5ec --- /dev/null +++ b/ebook/pt_br/content/020-nginx-and-apache-log-parser.md @@ -0,0 +1,83 @@ +# BASH Script parser to Summarize Your NGINX and Apache Access Logs + +One of the first things that I would usually do in case I notice a high CPU usage on some of my Linux servers would be to check the process list with either top or htop and in case that I notice a lot of Apache or Nginx process I would quickly check my access logs to determine what has caused or is causing the CPU spike on my server or to figure out if anything malicious is going on. + +Sometimes reading the logs could be quite intimidating as the log might be huge and going though it manually could take a lot of time. Also, the raw log format could be confusing for people with less experience. + +Just like the previous chapter, this chapter is going to be a challenge! You need to write a short bash script that would summarize the whole access log for you without the need of installing any additional software. + +# Script requirements + +This BASH script needs to parse and summarize your access logs and provide you with very useful information like: + +* The 20 top pages with the most POST requests +* The 20 top pages with the most GET requests +* Top 20 IP addresses and their geo-location + +## Example script + +I already have prepared a demo script which you could use as a reference. But I encourage you to try and write the script yourself first and only then take a look at my script! + +In order to download the script, you can either clone the repository with the following command: + +```bash +git clone https://github.com/bobbyiliev/quick_access_logs_summary.git +``` + +Or run the following command which would download the script in your current directory: + +```bash +wget https://raw.githubusercontent.com/bobbyiliev/quick_access_logs_summary/master/spike_check +``` + +The script does not make any changes to your system, it only reads the content of your access log and summarizes it for you, however, once you've downloaded the file, make sure to review the content yourself. + +## Running the script + +All that you have to do once the script has been downloaded is to make it executable and run it. + +To do that run the following command to make the script executable: + +```bash +chmod +x spike_check +``` + +Then run the script: + +```bash +./spike_check /path/to/your/access_log +``` + +Make sure to change the path to the file with the actual path to your access log. For example if you are using Apache on an Ubuntu server, the exact command would look like this: + +```bash +./spike_check /var/log/apache2/access.log +``` + +If you are using Nginx the exact command would be almost the same, but with the path to the Nginx access log: + +```bash +./spike_check /var/log/nginx/access.log +``` + +## Understanding the output + +Once you run the script, it might take a while depending on the size of the log. + +The output that you would see should look like this: + +![Summarized access log](https://imgur.com/WWHVMrj.png) + +Essentially what we can tell in this case is that we've received 16 POST requests to our xmlrpc.php file which is often used by attackers to try and exploit WordPress websites by using various username and password combinations. + +In this specific case, this was not a huge brute force attack, but it gives us an early indication and we can take action to prevent a larger attack in the future. + +We can also see that there were a couple of Russian IP addresses accessing our site, so in case that you do not expect any traffic from Russia, you might want to block those IP addresses as well. + +## Conclusion + +This is an example of a simple BASH script that allows you to quickly summarize your access logs and determine if anything malicious is going on. + +Of course, you might want to also manually go through the logs as well but it is a good challenge to try and automate this with Bash! + +>{notice} This content was initially posted on [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) diff --git a/ebook/pt_br/content/021-how-to-send-emails-with-bash.md b/ebook/pt_br/content/021-how-to-send-emails-with-bash.md new file mode 100644 index 0000000..13a0892 --- /dev/null +++ b/ebook/pt_br/content/021-how-to-send-emails-with-bash.md @@ -0,0 +1,95 @@ +# Enviando e-mails com Bash e SSMTP + +SSMTP é uma ferramenta que entrega emails de um computador ou servidor para um host de email configurado. + +O SSMTP não é um servidor de e-mail em si e não recebe e-mails nem gerencia uma fila. + +Um de seus principais usos é encaminhar e-mails automatizados (como alertas do sistema) para fora de sua máquina e para um endereço de e-mail externo. + +## Pré-requisitos + +Você precisaria das seguintes coisas para poder concluir este tutorial com sucesso: + +* Acesso a um servidor Ubuntu 18.04 como usuário não root com privilégios sudo e um firewall ativo instalado em seu servidor. Para configurá-los, consulte nosso [Guia de configuração inicial do servidor para Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Um servidor SMTP junto com o nome de usuário e a senha SMTP, isso também funcionaria com o servidor SMTP do Gmail, ou você pode configurar seu próprio servidor SMTP seguindo as etapas deste tutorial em [ tutoriais/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16-04](Como instalar e configurar o Postfix como um servidor SMTP somente para envio no Ubuntu 16.04) + +## Instalando o SSMTP + +Para instalar o SSMTP, você precisará primeiro atualizar seu cache apt com: + +```bash +sudo apt update +``` + +Em seguida, execute o seguinte comando para instalar o SSMTP: + +```bash +sudo apt install ssmtp +``` + +Outra coisa que você precisaria instalar é o `mailutils`, para isso execute o seguinte comando: + +```bash +sudo apt install mailutils +``` + +## Configurando o SSMTP + +Agora que você tem o `ssmtp` instalado, para configurá-lo para usar seu servidor SMTP ao enviar e-mails, você precisa editar o arquivo de configuração SSMTP. + +Usando seu editor de texto favorito abra o arquivo `/etc/ssmtp/ssmtp.conf`: + +```bash +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Você precisa incluir a configuração do seu SMTP: + +``` +root=postmaster +mailhub=<^>seu_smtp_host.com<^>:587 +hostname=<^>seu_hostname<^> +AuthUser=<^>seu_gmail_username@your_smtp_host.com<^> +AuthPass=<^>sua_gmail_senha<^> +FromLineOverride=YES +UseSTARTTLS=YES +``` + +Salve o arquivo e saia. + +## Enviando e-mails com SSMTP + +Feita a configuração, para enviar um e-mail basta executar o seguinte comando: + +```bash +echo "<^>Aqui adicione o corpo do seu email<^>" | mail -s "<^>Aqui especifique o assunto do seu e-mail<^>" <^>seu_receptor_email@seudominio.com<^> +``` + +Você pode executar isso diretamente em seu terminal ou incluí-lo em seus scripts bash. + +## Enviando um arquivo com SSMTP (opcional) + +Se você precisar enviar arquivos como anexos, você pode usar `mpack`. + +Para instalar o `mpack` execute o seguinte comando: + +```bash +sudo apt install mpack +``` + +Em seguida, para enviar um email com um arquivo anexado, execute o seguinte comando. + +```bash +mpack -s "<^>Seu assunto aqui<^>" your_file.zip <^>your_recepient_email@yourdomain.com<^> +``` + +O comando acima enviaria um email para `<^>your_recepient_email@yourdomain.com<^>` com o `<^>your_file.zip<^>` anexado. + +## Conclusão + +O SSMTP é uma maneira excelente e confiável de implementar a funcionalidade de email SMTP diretamente em scripts bash. + +Para obter mais informações sobre o SSMTP, recomendo verificar a documentação oficial [aqui](https://wiki.archlinux.org/index.php/SSMTP). + +>{notice} Este conteúdo foi postado inicialmente no [fórum da comunidade DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp ). diff --git a/ebook/pt_br/content/022-bash-password-generator.md b/ebook/pt_br/content/022-bash-password-generator.md new file mode 100644 index 0000000..faf3536 --- /dev/null +++ b/ebook/pt_br/content/022-bash-password-generator.md @@ -0,0 +1,144 @@ +# Script Bash do Gerador de Senhas + +Não é incomum uma situação em que você precisará gerar uma senha aleatória que possa ser usada para qualquer instalação de software ou quando você se inscrever em qualquer site. + +Existem muitas opções para conseguir isso. Você pode usar um gerenciador de senhas/cofre onde geralmente tem a opção de gerar uma senha aleatoriamente ou usar um site que possa gerar a senha em seu nome. + +Você também pode usar o Bash em seu terminal (linha de comando) para gerar uma senha que você pode usar rapidamente. Existem muitas maneiras de conseguir isso e vou me certificar de cobrir algumas delas e deixar para você escolher qual opção é mais adequada às suas necessidades. + +## :aviso: Segurança + +**Este script destina-se a praticar suas habilidades de script bash. Você pode se divertir enquanto faz projetos simples com o BASH, mas a segurança não é brincadeira, portanto, certifique-se de não salvar suas senhas em texto simples em um arquivo local ou anotá-las à mão em um pedaço de papel.** + +**Recomendarei a todos que usem provedores seguros e confiáveis ​​para gerar e salvar as senhas.** + +## Resumo do roteiro + +Deixe-me primeiro fazer um resumo rápido do que nosso script vai fazer.: + +1. Teremos a opção de escolher o tamanho dos caracteres da senha quando o script for executado. +2. O script gerará 5 senhas aleatórias com o comprimento especificado na etapa 1 + +## Pré-requisitos + +Você precisaria de um terminal bash e um editor de texto. Você pode usar qualquer editor de texto como vi, vim, nano ou Visual Studio Code. + +Estou executando o script localmente no meu laptop Linux, mas se você estiver usando o Windows PC, poderá executar o ssh em qualquer servidor de sua escolha e executar o script lá. + +Embora o script seja bastante simples, ter algum conhecimento básico de script BASH ajudará você a entender melhor o script e como ele está funcionando. + +## Gerar uma senha aleatória + +Um dos grandes benefícios do Linux é que você pode fazer muitas coisas usando métodos diferentes. Quando se trata de gerar uma string aleatória de caracteres, também não é diferente. + +Você pode usar vários comandos para gerar uma sequência aleatória de caracteres. Vou cobrir alguns deles e fornecer alguns exemplos. + +- Usando o comando ```date```. +O comando date produzirá a data e hora atuais. No entanto, também manipulamos ainda mais a saída para usá-la como senha gerada aleatoriamente. Podemos fazer o hash da data usando md5, sha ou apenas executá-la em base64. Estes são alguns exemplos: + +``` +date | md5sum +94cb1cdecfed0699e2d98acd9a7b8f6d - +``` + +usando sha256sum: + +``` +date | sha256sum +30a0c6091e194c8c7785f0d7bb6e1eac9b76c0528f02213d1b6a5fbcc76ceff4 - +``` + +usando base64: + +``` +date | base64 +0YHQsSDRj9C90YMgMzAgMTk6NTE6NDggRUVUIDIwMjEK +``` + +- Também podemos usar openssl para gerar bytes pseudo-aleatórios e executar a saída através de base64. Uma saída de exemplo será: + +``` +openssl rand -base64 10 +9+soM9bt8mhdcw== +``` + +Tenha em mente que o openssl pode não estar instalado em seu sistema, então é provável que você precise instalá-lo primeiro para usá-lo. + +- A maneira mais preferida é usar o gerador de números pseudoaleatórios - /dev/urandom +uma vez que se destina à maioria dos propósitos criptográficos. Também precisaríamos manipular a saída usando ```tr``` para traduzi-la. Um exemplo de comando é: + +``` +tr -cd '[:alnum:]' < /dev/urandom | fold -w10 | head -n 1 +``` + +Com este comando pegamos a saída de /dev/urandom e traduzimos com ```tr``` enquanto usamos todas as letras e dígitos e imprimimos o número desejado de caracteres. + +## O script + +Primeiro começamos o script com o shebang. Nós o usamos para informar ao sistema operacional qual interpretador usar para analisar o restante do arquivo. + +``` +#!/bin/bash +``` + +Podemos então continuar e pedir ao usuário alguma entrada. Neste caso, gostaríamos de saber quantos caracteres a senha precisa ter: + +``` +# Pedir ao usuário o comprimento da senha +clear +printf "\n" +read -p "How many characters you would like the password to have? " pass_length +printf "\n" +``` + +Gere as senhas e imprima-as para que o usuário possa usá-las. + +``` +# É aqui que a mágica acontece! +# Gera uma lista de 10 strings e corta para o valor desejado fornecido pelo usuário + +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_lenght} | head -n 1); done + +# Imprime as strings +printf "$pass_output\n" +printf "Goodbye, ${USER}\n" +``` + +## O script completo + +``` +#!/bin/bash +#======================================= +# Gerador de senhas com opção de login +#======================================= + + +# Pergunta ao usuário o comprimento da string +Claro +clear +printf "\n" +read -p "How many characters you would like the password to have? " pass_length +printf "\n" + + +# É aqui que a mágica acontece! +# Gera uma lista de 10 strings e corta para o valor desejado fornecido pelo usuário + +for i in {1..10}; do (tr -cd '[:alnum:]' < /dev/urandom | fold -w${pass_lenght} | head -n 1); done + +# Imprime as strings +printf "$pass_output\n" +printf "Goodbye, ${USER}\n" +``` + +## Conclusão + +É basicamente assim que você pode usar um script bash simples para gerar senhas aleatórias. + +:aviso: **Como já mencionado, certifique-se de usar senhas fortes para garantir que sua conta esteja protegida. Além disso, sempre que possível, use a autenticação de dois fatores, pois isso fornecerá uma camada adicional de segurança para sua conta.** + +Enquanto o script está funcionando bem, ele espera que o usuário forneça a entrada solicitada. Para evitar quaisquer problemas, você precisaria fazer algumas verificações mais avançadas na entrada do usuário para garantir que o script continue funcionando bem, mesmo que a entrada fornecida não corresponda às nossas necessidades. + +## Contribuído por + +[Alex Georgiev](https://twitter.com/alexgeorgiev17) diff --git a/ebook/pt_br/content/023-bash-redirection.md b/ebook/pt_br/content/023-bash-redirection.md new file mode 100644 index 0000000..edb5678 --- /dev/null +++ b/ebook/pt_br/content/023-bash-redirection.md @@ -0,0 +1,262 @@ +# Redirecionamento no Bash + +Um superusuário Linux deve ter um bom conhecimento de pipes e redirecionamento no Bash. É um componente essencial do sistema e muitas vezes é útil no campo da Administração de Sistemas Linux. + +Quando você executa um comando como ``ls``, ``cat``, etc, você obtém alguma saída no terminal. Se você escrever um comando errado, passar um sinalizador errado ou um argumento de linha de comando errado, você obterá uma saída de erro no terminal. +Em ambos os casos, você recebe algum texto. Pode parecer "apenas texto" para você, mas o sistema trata esse texto de forma diferente. Esse identificador é conhecido como Descritor de Arquivo (fd). + +No Linux, existem 3 Descritores de Arquivo, **STDIN** (0); **STDOUT** (1) e **STDERR** (2). + +* **STDIN** (fd: 0): Gerencia a entrada no terminal. +* **STDOUT** (fd: 1): Gerencia o texto de saída no terminal. +* **STDERR** (fd: 2): Gerencia o texto de erro no terminal. + +# Diferença entre Pipes e Redirecionamentos + +Ambos os *pipes* e *redirections* redirecionam os fluxos `(descritor de arquivo)` do processo que está sendo executado. A principal diferença é que os *redirecionamentos* lidam com o `fluxo de arquivos`, enviando o fluxo de saída para um arquivo ou enviando o conteúdo de um determinado arquivo para o fluxo de entrada do processo. + +Por outro lado, um pipe conecta dois comandos enviando o fluxo de saída do primeiro para o fluxo de entrada do segundo. sem nenhum redirecionamento especificado. + +# Redirecionamento no Bash + +## STDIN (Entrada Padrão) + +Quando você insere algum texto de entrada para um comando que o solicita, na verdade você está inserindo o texto no descritor de arquivo **STDIN**. Execute o comando ``cat`` sem nenhum argumento de linha de comando. +Pode parecer que o processo parou, mas na verdade é ``cat`` pedindo **STDIN**. ``cat`` é um programa simples e imprimirá o texto passado para **STDIN**. No entanto, você pode estender o caso de uso redirecionando a entrada para os comandos que usam **STDIN**. + +Exemplo com ``cat``: + +``` +cat << EOF +Hello World! +How are you? +EOF +``` + +Isso simplesmente imprimirá o texto fornecido na tela do terminal: + +``` +Hello World! +How are you? +``` + +O mesmo pode ser feito com outros comandos que recebem entrada via STDIN. Tipo, ``wc``: + +``` +wc -l << EOF +Hello World! +How are you? +EOF +``` + +O sinalizador ``-l`` com ``wc`` conta o número de linhas. +Este bloco de código bash imprimirá o número de linhas na tela do terminal: + +``` +2 +``` + +## STDOUT (Saída Padrão) + +O texto normal sem erro na tela do terminal é impresso por meio do descritor de arquivo **STDOUT**. O **STDOUT** de um comando pode ser redirecionado para um arquivo, de forma que a saída do comando seja escrita em um arquivo ao invés de ser impressa na tela do terminal. +Isso é feito simplesmente com a ajuda dos operadores ``>`` e ``>>``. + +Exemplo: + +``` +echo "Hello World!" > file.txt +``` + +O comando a seguir não imprimirá "Hello World" na tela do terminal, ele criará um arquivo chamado ``file.txt`` e escreverá a string "Hello World" nele. +Isso pode ser verificado executando o comando ``cat`` no arquivo ``file.txt``. + +``` +cat file.txt +``` + +No entanto, toda vez que você redirecionar o **STDOUT** de qualquer comando várias vezes para o mesmo arquivo, ele removerá o conteúdo existente do arquivo para gravar os novos. + +Exemplo: + +``` +echo "Hello World!" > file.txt +echo "How are you?" > file.txt +``` + +Ao executar ``cat`` no arquivo ``file.txt``: + +``` +cat file.txt +``` + +Você só receberá o "How are you?" cadeia impressa. + +``` +Como você está? +``` + +Isso ocorre porque a string "Hello World" foi substituída. +Este comportamento pode ser evitado usando o operador ``>>``. + +O exemplo acima pode ser escrito como: + +``` +echo "Olá Mundo!" > file.txt +echo "Como você está?" >> file.txt +``` + +Ao executar o ``cat`` no arquivo ``file.txt``, você obterá o resultado desejado. + +``` +Olá Mundo! +Como você está? +``` + +Alternativamente, o operador de redirecionamento para **STDOUT** também pode ser escrito como ``1>``. Curti, + +``` +echo "Olá Mundo!" 1> file.txt +``` + +## STDERR (Erro padrão) + +O texto de erro na tela do terminal é impresso através do **STDERR** do comando. Por exemplo: + +``` +ls --hello 2> error.txt +``` + +daria uma mensagem de erro. Esta mensagem de erro é o **STDERR** do comando. + +**STDERR** pode ser redirecionado usando o operador ``2>``. + +``` +ls --hello 2> error.txt +``` + +Este comando irá redirecionar a mensagem de erro para o arquivo ``error.txt`` e gravá-la nele. Isso pode ser verificado executando o comando ``cat`` no arquivo ``error.txt``. + +Você também pode usar o operador ``2>>`` para **STDERR** assim como usou ``>>`` para **STDOUT**. + +Mensagens de erro em scripts Bash podem ser indesejáveis ​​às vezes. Você pode optar por ignorá-los redirecionando a mensagem de erro para o arquivo ``/dev/null``. +``/dev/null`` é um pseudodispositivo que recebe texto e o descarta imediatamente. + +O exemplo acima pode ser escrito a seguir para ignorar completamente o texto do erro: + +``` +ls --hello 2> /dev/null +``` + +Claro, você pode redirecionar **STDOUT** e **STDERR** para o mesmo comando ou script. + +``` +./install_package.sh > output.txt 2> error.txt +``` + +Ambos podem ser redirecionados para o mesmo arquivo também. + +``` +./install_package.sh > arquivo.txt 2> arquivo.txt +``` + +Há também uma maneira mais curta de fazer isso. + +``` +./install_package.sh > arquivo.txt 2>&1 +``` + +# Tubulação (Piping) + +Até agora vimos como redirecionar **STDOUT**, **STDIN** e **STDOUT** de e para um arquivo. +Para concatenar a saída do programa *(comando)* como a entrada de outro programa *(comando)* você pode usar uma barra vertical `|`. + +Exemplo: + +``` +ls | grep ".txt" +``` + +Este comando listará os arquivos no diretório atual e passará a saída para o comando *`grep`*, que filtrará a saída para mostrar apenas os arquivos que contêm a string ".txt". + +Sintaxe: + +``` +[tempo [-p]] [!] comando1 [ | ou |& comando2 ] … +``` + +Você também pode construir cadeias arbitrárias de comandos conectando-os para obter um resultado poderoso. + +Este exemplo cria uma lista de todos os usuários que possuem um arquivo em um determinado diretório, bem como quantos arquivos e diretórios eles possuem: + +``` +ls -l /projects/bash_scripts | tail -n +2 | sed 's/\s\s*/ /g' | cut -d ' ' -f 3 | sort | uniq -c +``` + +Resultado: + +``` +8 anne +34 harry +37 tina +18 ryan +``` + +# AquiDocumento + +O símbolo `<<` pode ser usado para criar um arquivo temporário [heredoc] e redirecioná-lo na linha de comando. + +``` +COMMAND << EOF + ContentOfDocument + ... + ... +EOF +``` + +Observe aqui que `EOF` representa o delimitador fim do arquivo (end of file) do heredoc. Na verdade, podemos usar qualquer palavra alfanumérica em seu lugar para significar o início e o fim do arquivo. Por exemplo, este é um heredoc válido: + +``` +cat << randomword1 +Este script imprimirá essas linhas no terminal. +Observe que cat pode ler a partir da entrada padrão. Usando este heredoc, podemos +crie um arquivo temporário com essas linhas como conteúdo e canalize isso +em gato. +randomword1 +``` + +Efetivamente, aparecerá como se o conteúdo do heredoc fosse canalizado para o comando. Isso pode tornar o script muito limpo se várias linhas precisarem ser canalizadas para um programa. + +Além disso, podemos anexar mais tubos (pipes) como mostrado: + +``` +cat << randomword1 | wc +Este script imprimirá essas linhas no terminal. +Observe que cat pode ler a partir da entrada padrão. Usando este heredoc, podemos +crie um arquivo temporário com essas linhas como conteúdo e canalize isso +em gato. +randomword1 +``` + +Além disso, variáveis ​​pré-definidas podem ser usadas dentro dos heredocs. + +# HereString + +Herestrings são bastante semelhantes aos heredocs, mas usam `<<<`. Eles são usados ​​para strings de linha única que precisam ser canalizadas para algum programa. Isso parece mais limpo do que heredocs, pois não precisamos especificar o delimitador. + +``` +wc <<<"esta é uma maneira fácil de passar strings para o stdin de um programa (aqui wc)" +``` + +Assim como heredocs, herestrings podem conter variáveis. + +## Resumo + +|**Operador** |**Descrição** | +|:---|:---| +|`>`|`Salvar saída em um arquivo`| +|`>>`|`Anexar saída a um arquivo`| +|`<`|`Ler entrada de um arquivo`| +|`2>`|`Redirecionar mensagens de erro`| +|`\|`|`Envia a saída de um programa como entrada para outro programa`| +|`<<`|`Coloque várias linhas em um programa de forma limpa`| +|`<<<`|`Coloque uma única linha em um programa de forma limpa`| diff --git a/ebook/pt_br/content/100-bash-wrap-up.md b/ebook/pt_br/content/100-bash-wrap-up.md new file mode 100644 index 0000000..4c203fa --- /dev/null +++ b/ebook/pt_br/content/100-bash-wrap-up.md @@ -0,0 +1,15 @@ +# Embrulhar + +Parabéns! Você acabou de concluir o guia básico do Bash! + +Se você achou isso útil, certifique-se de estrelar o projeto no [GitHub](https://github.com/bobbyiliev/introduction-to-bash-scripting)! + +Se você tiver alguma sugestão de melhoria, certifique-se de contribuir com solicitações de pull ou problemas em aberto. + +Nesta introdução ao livro de scripts Bash, abordamos apenas o básico, mas você ainda tem o suficiente para começar a criar alguns scripts incríveis e automatizar tarefas diárias! + +Como próximo passo, tente escrever seu próprio roteiro e compartilhá-lo com o mundo! Esta é a melhor maneira de aprender qualquer nova linguagem de programação ou script! + +Caso este livro tenha inspirado você a escrever alguns scripts legais do Bash, certifique-se de twittar sobre ele e marcar [@bobbyiliev_](https://twitter.com) para que possamos conferir! + +Parabéns novamente por concluir este livro! diff --git a/ebook/pt_br/epub.yml b/ebook/pt_br/epub.yml new file mode 100644 index 0000000..78b0b85 --- /dev/null +++ b/ebook/pt_br/epub.yml @@ -0,0 +1,14 @@ +--- +# Generate an ePub by running: +# pandoc content/*.md epub.yml -o export/introduction-to-bash-scripting.epub +title: Introduction to Bash Scripting +author: Bobby Iliev +cover-image: assets/cover.jpg +rights: MIT License +lang: en-US +tags: [bash, Unix, Linux] + +# Filter preferences: +# - pandoc-crossref +linkReferences: true +--- \ No newline at end of file diff --git a/ebook/pt_br/export/introduction-to-bash-scripting-dark.pdf b/ebook/pt_br/export/introduction-to-bash-scripting-dark.pdf new file mode 100644 index 0000000..ba07570 Binary files /dev/null and b/ebook/pt_br/export/introduction-to-bash-scripting-dark.pdf differ diff --git a/ebook/pt_br/export/introduction-to-bash-scripting-light.pdf b/ebook/pt_br/export/introduction-to-bash-scripting-light.pdf new file mode 100644 index 0000000..e7f23d5 Binary files /dev/null and b/ebook/pt_br/export/introduction-to-bash-scripting-light.pdf differ diff --git a/ebook/pt_br/export/introduction-to-bash-scripting.epub b/ebook/pt_br/export/introduction-to-bash-scripting.epub new file mode 100644 index 0000000..2abb9ab Binary files /dev/null and b/ebook/pt_br/export/introduction-to-bash-scripting.epub differ diff --git a/ebook/pt_br/export/sample-.introduction-to-bash-scripting-dark.pdf b/ebook/pt_br/export/sample-.introduction-to-bash-scripting-dark.pdf new file mode 100644 index 0000000..9ea2b2d Binary files /dev/null and b/ebook/pt_br/export/sample-.introduction-to-bash-scripting-dark.pdf differ diff --git a/ebook/pt_br/export/sample-.introduction-to-bash-scripting-light.pdf b/ebook/pt_br/export/sample-.introduction-to-bash-scripting-light.pdf new file mode 100644 index 0000000..552e294 Binary files /dev/null and b/ebook/pt_br/export/sample-.introduction-to-bash-scripting-light.pdf differ diff --git a/ebook/pt_br/export/sample-introduction-to-bash-scripting-dark.pdf b/ebook/pt_br/export/sample-introduction-to-bash-scripting-dark.pdf new file mode 100644 index 0000000..9d75dbe Binary files /dev/null and b/ebook/pt_br/export/sample-introduction-to-bash-scripting-dark.pdf differ diff --git a/ebook/pt_br/export/sample-introduction-to-bash-scripting-light.pdf b/ebook/pt_br/export/sample-introduction-to-bash-scripting-light.pdf new file mode 100644 index 0000000..e5a6ea4 Binary files /dev/null and b/ebook/pt_br/export/sample-introduction-to-bash-scripting-light.pdf differ diff --git a/ebook/pt_br/ibis.php b/ebook/pt_br/ibis.php new file mode 100644 index 0000000..3d6b7d1 --- /dev/null +++ b/ebook/pt_br/ibis.php @@ -0,0 +1,34 @@ + 'Introdução ao Bash Scripting', + + /** + * The author name. + */ + 'author' => 'Bobby Iliev', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'Esta é uma amostra de "Introdução ao Bash Scripting" by Bobby Iliev.
+ Para mais d\informações, Clique aqui.', +]; diff --git a/ebook/sp/assets/content/000-about-the-author.md b/ebook/sp/assets/content/000-about-the-author.md new file mode 100644 index 0000000..dbba5e4 --- /dev/null +++ b/ebook/sp/assets/content/000-about-the-author.md @@ -0,0 +1 @@ +../../../en/content/000-about-the-author.md ../../../en/content/001-introduction-to-bash.md ../../../en/content/002-bash-structure.md ../../../en/content/003-bash-hello-world.md ../../../en/content/004-bash-variables.md ../../../en/content/005-bash-user-input.md ../../../en/content/006-bash-comments.md ../../../en/content/007-bash-arguments.md ../../../en/content/008-bash-arrays.md ../../../en/content/009-bash-conditional-expressions.md ../../../en/content/010-bash-conditionals.md ../../../en/content/011-bash-loops.md ../../../en/content/012-bash-functions.md ../../../en/content/013-debugging-and-testing.md ../../../en/content/014-creating-custom-bash-commands.md ../../../en/content/015-writing-your-first-bash-script.md ../../../en/content/016-creating-an-interactive-menu-in-bash.md ../../../en/content/017-executing-bash-script-on-multiple-remote-server.md ../../../en/content/018-working-with-json-in-bash-using-jq.md ../../../en/content/019-working-with-cloudflare-api-with-bash.md ../../../en/content/020-nginx-and-apache-log-parser.md ../../../en/content/021-how-to-send-emails-with-bash.md ../../../en/content/022-bash-password-generator.md ../../../en/content/023-bash-redirection.md ../../../en/content/024-automating-wordpress-lamp-with-bash.md ../../../en/content/100-bash-wrap-up.md \ No newline at end of file diff --git a/ebook/sp/assets/content/001-introduction-to-bash.md b/ebook/sp/assets/content/001-introduction-to-bash.md new file mode 100644 index 0000000..8ae865e --- /dev/null +++ b/ebook/sp/assets/content/001-introduction-to-bash.md @@ -0,0 +1,11 @@ +# Introducción a las secuencias de comandos Bash + +¡Bienvenido a esta guía de formación básica de Bash! En este **curso intensivo de bash**, aprenderá los **conceptos básicos de Bash** para que pueda comenzar a escribir sus propios scripts de Bash y automatizar sus tareas diarias. + +Bash es un shell y lenguaje de comandos de Unix. Está ampliamente disponible en varios sistemas operativos y también es el intérprete de comandos predeterminado en la mayoría de los sistemas Linux. + +Bash significa Bourne-Again SHell. Al igual que con otros shells, puede usar Bash de forma interactiva directamente en su terminal y, además, puede usar Bash como cualquier otro lenguaje de programación para escribir scripts. Este libro le ayudará a aprender los conceptos básicos de las secuencias de comandos Bash, incluidas las variables Bash, la entrada del usuario, los comentarios, los argumentos, las matrices, las expresiones condicionales, los condicionales, los bucles, las funciones, la depuración y las pruebas. + +Los scripts Bash son excelentes para automatizar cargas de trabajo repetitivas y pueden ayudarlo a ahorrar tiempo considerablemente. Por ejemplo, imagine trabajar con un grupo de cinco desarrolladores en un proyecto que requiere una configuración de entorno tediosa. Para que el programa funcione correctamente, cada desarrollador debe configurar manualmente el entorno. Se trata de la misma y muy larga tarea (preparar el entorno) que se repite al menos cinco veces. ¡Aquí es donde usted y los scripts Bash vienen al rescate! Entonces, en lugar de eso, creas un archivo de texto simple que contiene todas las instrucciones necesarias y lo compartes con tus compañeros de equipo. Y ahora, todo lo que tienen que hacer es ejecutar el script Bash y todo se creará para ellos. + +Para escribir scripts Bash, solo necesita una terminal UNIX y un editor de texto como Sublime Text, VS Code o un editor basado en terminal como vim o nano. \ No newline at end of file diff --git a/ebook/sp/assets/content/002-bash-structure.md b/ebook/sp/assets/content/002-bash-structure.md new file mode 100644 index 0000000..b954187 --- /dev/null +++ b/ebook/sp/assets/content/002-bash-structure.md @@ -0,0 +1,25 @@ +# Estructura de bash + +Comencemos creando un nuevo archivo con una extensión `.sh`. Como ejemplo, podríamos crear un archivo llamado `devdojo.sh`. + +Para crear ese archivo, puede usar el comando `touch`: + +```golpecito +toque devdojo.sh +``` + +O puedes usar tu editor de texto en su lugar: + +```golpecito +nano devdojo.sh +``` + +Para ejecutar/ejecutar un archivo de script bash con el intérprete de shell bash, la primera línea de un archivo de script debe indicar la ruta absoluta al ejecutable bash: + +```golpecito +#!/bin/bash +``` + +Esto también se llama [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)). + +Todo lo que hace el shebang es indicarle al sistema operativo que ejecute el script con el ejecutable `/bin/bash`. \ No newline at end of file diff --git a/ebook/sp/assets/content/003-bash-hello-world.md b/ebook/sp/assets/content/003-bash-hello-world.md new file mode 100644 index 0000000..3e829a5 --- /dev/null +++ b/ebook/sp/assets/content/003-bash-hello-world.md @@ -0,0 +1,41 @@ +# Bash Hola mundo + +Una vez que hayamos creado nuestro archivo `devdojo.sh` y hayamos especificado el shebang bash en la primera línea, estamos listos para crear nuestro primer script bash `Hello World`. + +Para hacer eso, abra el archivo `devdojo.sh` nuevamente y agregue lo siguiente después de la línea `#!/bin/bash`: + +```golpecito +#!/bin/bash + +eco "¡Hola mundo!" +``` + +Guarda el archivo y cierra. + +Después de eso, haga que el script sea ejecutable ejecutando: + +```golpecito +chmod +x devdojo.sh +``` + +Después de eso ejecute el archivo: + +```golpecito +./devdojo.sh +``` + +Verá un mensaje "Hola mundo" en la pantalla. + +Otra forma de ejecutar el script sería: + +```golpecito +bash devdojo.sh +``` + +Como bash se puede usar de forma interactiva, puede ejecutar el siguiente comando directamente en su terminal y obtendrá el mismo resultado: + +```golpecito +echo "¡Hola DevDojo!" +``` + +Crear un script es útil una vez que tienes que combinar varios comandos. \ No newline at end of file diff --git a/ebook/sp/assets/content/004-bash-variables.md b/ebook/sp/assets/content/004-bash-variables.md new file mode 100644 index 0000000..d226cab --- /dev/null +++ b/ebook/sp/assets/content/004-bash-variables.md @@ -0,0 +1,131 @@ +# Variables de bash + +Como en cualquier otro lenguaje de programación, también puedes utilizar variables en Bash Scripting. Sin embargo, no existen tipos de datos y una variable en Bash puede contener tanto números como caracteres. + +Para asignar un valor a una variable, todo lo que necesitas hacer es usar el signo `=`: + +```golpecito +nombre="DevDojo" +``` + +>{aviso} como nota importante, no puede tener espacios antes y después del signo `=`. + +Después de eso, para acceder a la variable, debe usar `$` y hacer referencia a ella como se muestra a continuación: + +```golpecito +eco $ nombre +``` + +No es necesario colocar el nombre de la variable entre llaves, pero se considera una buena práctica y le recomendaría que las utilice siempre que pueda: + +```golpecito +eco ${nombre} +``` + +El código anterior generaría: `DevDojo` ya que este es el valor de nuestra variable `name`. + +A continuación, actualicemos nuestro script `devdojo.sh` e incluyamos una variable en él. + +Nuevamente, puedes abrir el archivo `devdojo.sh` con tu editor de texto favorito, aquí estoy usando nano para abrir el archivo: + +```golpecito +nano devdojo.sh +``` + +Agregando nuestra variable `nombre` aquí en el archivo, con un mensaje de bienvenida. Nuestro archivo ahora se ve así: + +```golpecito +#!/bin/bash + +nombre="DevDojo" + +echo "Hola $nombre" +``` + +Guárdelo y ejecute el archivo usando el siguiente comando: + +```golpecito +./devdojo.sh +``` + +Verá el siguiente resultado en su pantalla: + +```golpecito +Hola DevDojo +``` + +Aquí hay un resumen del script escrito en el archivo: + +* `#!/bin/bash` - Al principio, especificamos nuestro shebang. +* `name=DevDojo` - Luego, definimos una variable llamada `name` y le asignamos un valor. +* `echo "Hola $name"` - Finalmente, mostramos el contenido de la variable en la pantalla como mensaje de bienvenida usando `echo` + +También puede agregar múltiples variables en el archivo como se muestra a continuación: + +```golpecito +#!/bin/bash + +nombre="DevDojo" +saludo="Hola" + +echo "$saludo $nombre" +``` + +Guarde el archivo y ejecútelo nuevamente: + +```golpecito +./devdojo.sh +``` + +Verá el siguiente resultado en su pantalla: + +```golpecito +Hola DevDojo +``` +Tenga en cuenta que no es necesario agregar punto y coma `;` al final de cada línea. Funciona en ambos sentidos, ¡un poco como otros lenguajes de programación como JavaScript! + + +También puede agregar variables en la línea de comando fuera del script Bash y pueden leerse como parámetros: + +```golpecito +./devdojo.sh ¡Bobby amigo! +``` +Este script toma dos parámetros `Bobby` y `buddy!` separados por espacios. En el archivo `devdojo.sh` tenemos lo siguiente: + +```golpecito +#!/bin/bash + +echo "Hola" $1 + +``` +`$1` es la primera entrada (`Bobby`) en la línea de comando. De manera similar, podría haber más entradas y todas ellas están referenciadas por el signo `$` y su respectivo orden de entrada. Esto significa que se hace referencia a `buddy!` usando `$2`. Otro método útil para leer variables es `$@` que lee todas las entradas. + +Ahora cambiemos el archivo `devdojo.sh` para comprenderlo mejor: + +```golpecito +#!/bin/bash + +echo "Hola" $1 + +# $1: primer parámetro + +echo "Hola" $2 + +# $2: segundo parámetro + +echo "Hola" $@ + +#$@: todos +``` +La salida para: + +```golpecito +./devdojo.sh ¡Bobby amigo! +``` +Seria el siguiente: + +```golpecito +Hola bobby +¡Hola amigo! +¡Hola amigo Bobby! +``` \ No newline at end of file diff --git a/ebook/sp/assets/content/005-bash-user-input.md b/ebook/sp/assets/content/005-bash-user-input.md new file mode 100644 index 0000000..4f36476 --- /dev/null +++ b/ebook/sp/assets/content/005-bash-user-input.md @@ -0,0 +1,54 @@ +# Entrada de usuario Bash + +Con el script anterior, definimos una variable y mostramos el valor de la variable en la pantalla con el `echo $name`. + +Ahora sigamos adelante y pidamos información al usuario. Para hacerlo nuevamente, abra el archivo con su editor de texto favorito y actualice el script de la siguiente manera: + +```golpecito +#!/bin/bash + +eco "¿Cuál es tu nombre?" +leer nombre + +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +Lo anterior solicitará al usuario una entrada y luego almacenará esa entrada como una cadena/texto en una variable. + +Luego podemos usar la variable e imprimirles un mensaje. + +El resultado del script anterior sería: + +* Primero ejecute el script: + +```golpecito +./devdojo.sh +``` + +* Luego, se le pedirá que ingrese su nombre: + +``` +¿Cómo te llamas? +Poli +``` + +* Una vez que haya escrito su nombre, simplemente presione Intro y obtendrá el siguiente resultado: + +``` +Hola bobby +¡Bienvenidos a DevDojo! +``` + +Para reducir el código, podríamos cambiar la primera declaración `echo` con `read -p`, el comando `read` usado con el indicador `-p` imprimirá un mensaje antes de solicitar al usuario su entrada: + +```golpecito +#!/bin/bash + +leer -p "¿Cuál es tu nombre?" nombre + +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +¡Asegúrate de probarlo tú mismo también! \ No newline at end of file diff --git a/ebook/sp/assets/content/006-bash-comments.md b/ebook/sp/assets/content/006-bash-comments.md new file mode 100644 index 0000000..7661719 --- /dev/null +++ b/ebook/sp/assets/content/006-bash-comments.md @@ -0,0 +1,27 @@ +# Comentarios bash + +Como con cualquier otro lenguaje de programación, puedes agregar comentarios a tu script. Los comentarios se utilizan para dejarse notas a través de su código. + +Para hacer eso en Bash, debe agregar el símbolo `#` al principio de la línea. Los comentarios nunca se mostrarán en la pantalla. + +A continuación se muestra un ejemplo de un comentario: + +```golpecito +# Este es un comentario y no se mostrará en la pantalla. +``` + +Sigamos adelante y agreguemos algunos comentarios a nuestro script: + +```golpecito +#!/bin/bash + +# Preguntar al usuario su nombre + +leer -p "¿Cuál es tu nombre?" nombre + +# Saludar al usuario +echo "Hola $nombre" +echo "¡Bienvenido a DevDojo!" +``` + +Los comentarios son una excelente manera de describir algunas de las funciones más complejas directamente en sus scripts para que otras personas puedan orientarse en su código con facilidad. diff --git a/ebook/sp/assets/content/007-bash-arguments.md b/ebook/sp/assets/content/007-bash-arguments.md new file mode 100644 index 0000000..08cc58d --- /dev/null +++ b/ebook/sp/assets/content/007-bash-arguments.md @@ -0,0 +1,77 @@ +# Argumentos de Bash + +Puede pasar argumentos a su script de shell cuando lo ejecute. Para pasar un argumento, sólo necesita escribirlo justo después del nombre de su script. Por ejemplo: + +```golpecito +./devdojo.com tu_argumento +``` + +En el script, podemos usar `$1` para hacer referencia al primer argumento que especificamos. + +Si pasamos un segundo argumento, estará disponible como `$2` y así sucesivamente. + +Creemos un script corto llamado `arguments.sh` como ejemplo: + +```golpecito +#!/bin/bash + +echo "El argumento uno es $1" +echo "El argumento dos es $2" +echo "El argumento tres es $3" +``` + +Guarde el archivo y hágalo ejecutable: + +```golpecito +chmod +x argumentos.sh +``` + +Luego ejecute el archivo y pase **3** argumentos: + +```golpecito +./arguments.sh perro gato pájaro +``` + +El resultado que obtendrías sería: + +```golpecito +El argumento uno es perro. +El argumento dos es el gato. +El tercer argumento es el pájaro. +``` + +Para hacer referencia a todos los argumentos, puede utilizar `$@`: + +```golpecito +#!/bin/bash + +echo "Todos los argumentos: $@" +``` + +Si ejecuta el script nuevamente: + +```golpecito +./arguments.sh perro gato pájaro +``` + +Obtendrá el siguiente resultado: + +``` +Todos los argumentos: perro gato pájaro +``` + +Otra cosa que debes tener en cuenta es que "$0" se usa para hacer referencia al script en sí. + +Esta es una excelente manera de crear un archivo autodestructivo si es necesario o simplemente obtener el nombre del script. + +Por ejemplo, creemos una secuencia de comandos que imprima el nombre del archivo y luego lo elimine: + +```golpecito +#!/bin/bash + +echo "El nombre del archivo es: $0 y se eliminará automáticamente." + +habitación -f $0 +``` + +Debe tener cuidado con la autoeliminación y asegurarse de tener una copia de seguridad de su secuencia de comandos antes de autoeliminarla. \ No newline at end of file diff --git a/ebook/sp/assets/content/008-bash-arrays.md b/ebook/sp/assets/content/008-bash-arrays.md new file mode 100644 index 0000000..7bf39b6 --- /dev/null +++ b/ebook/sp/assets/content/008-bash-arrays.md @@ -0,0 +1,113 @@ +# matrices bash + +Si alguna vez ha realizado alguna programación, probablemente ya esté familiarizado con las matrices. + +Pero en caso de que no seas desarrollador, lo principal que debes saber es que, a diferencia de las variables, las matrices pueden contener varios valores bajo un mismo nombre. + +Puede inicializar una matriz asignando valores divididos por espacios y encerrados en `()`. Ejemplo: + +```golpecito +my_array=("valor 1" "valor 2" "valor 3" "valor 4") +``` + +Para acceder a los elementos de la matriz, debe hacer referencia a ellos por su índice numérico. + +>{aviso} tenga en cuenta que debe utilizar llaves. + +* Acceda a un solo elemento, esto generaría: `valor 2` + +```golpecito +eco ${mi_matriz[1]} +``` + +* Esto devolvería el último elemento: `valor 4` + +```golpecito +eco ${mi_matriz[-1]} +``` + +* Al igual que con los argumentos de la línea de comando, usar `@` devolverá todos los argumentos en la matriz, de la siguiente manera: `valor 1 valor 2 valor 3 valor 4` + +```golpecito +eco ${mi_matriz[@]} +``` + +* Anteponer la matriz con un signo de almohadilla (`#`) generaría el número total de elementos en la matriz, en nuestro caso es `4`: + +```golpecito +eco ${#my_array[@]} +``` + +Asegúrate de probar esto y practicarlo al final con diferentes valores. + +## Subcadena en Bash :: Cortar + +Repasemos el siguiente ejemplo de corte de una cadena en Bash: + +```golpecito +#!/bin/bash + +letras=( "A""B""C""D""E") +eco ${letras[@]} +``` + +Este comando imprimirá todos los elementos de una matriz. + +Producción: + +```golpecito +$ABCDE +``` + + +Veamos algunos ejemplos más: + +- Ejemplo 1 + +```golpecito +#!/bin/bash + +letras=( "A""B""C""D""E") +b=${letras:0:2} +eco "${b}" +``` + +Este comando imprimirá una matriz desde el índice inicial 0 al 2, donde 2 es exclusivo. + +```golpecito +$AB +``` + + - Ejemplo 2 + +```golpecito +#!/bin/bash + +letras=( "A""B""C""D""E") +b=${letras::5} +eco "${b}" +``` + +Este comando imprimirá desde el índice base 0 al 5, donde 5 es exclusivo y el índice inicial está configurado de forma predeterminada en 0. + +```golpecito +$ABCDE +``` + +- Ejemplo 3 + +```golpecito +#!/bin/bash + +letras=( "A""B""C""D""E") +b=${letras:3} +eco "${b}" +``` + +Este comando imprimirá desde el índice inicial + 3 hasta el final de la matriz inclusive. + + ```golpecito + $DE + ``` + \ No newline at end of file diff --git a/ebook/sp/assets/content/009-bash-conditional-expressions.md b/ebook/sp/assets/content/009-bash-conditional-expressions.md new file mode 100644 index 0000000..d58d583 --- /dev/null +++ b/ebook/sp/assets/content/009-bash-conditional-expressions.md @@ -0,0 +1,186 @@ +# Expresiones condicionales de Bash + +En informática, las declaraciones condicionales, las expresiones condicionales y las construcciones condicionales son características de un lenguaje de programación, que realizan diferentes cálculos o acciones dependiendo de si una condición booleana especificada por el programador se evalúa como verdadera o falsa. + +En Bash, las expresiones condicionales son utilizadas por el comando compuesto `[[` y los comandos integrados `[` para probar los atributos del archivo y realizar comparaciones aritméticas y de cadenas. + +Aquí hay una lista de las expresiones condicionales de Bash más populares. No es necesario memorizarlos de memoria. ¡Simplemente puede consultar esta lista cuando la necesite! + +## Expresiones de archivo + +* Verdadero si el archivo existe. + +```golpecito +[[ -a ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un archivo especial de bloque. + +```golpecito +[[ -b ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un archivo de caracteres especiales. + +```golpecito +[[ -c ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un directorio. + +```golpecito +[[ -d ${archivo} ]] +``` + +* Verdadero si el archivo existe. + +```golpecito +[[ -e ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un archivo normal. + +```golpecito +[[ -f ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un enlace simbólico. + +```golpecito +[[ -h ${archivo} ]] +``` + +* Verdadero si el archivo existe y es legible. + +```golpecito +[[ -r ${archivo} ]] +``` + +* Verdadero si el archivo existe y tiene un tamaño mayor que cero. + +```golpecito +[[ -s ${archivo} ]] +``` + +* Verdadero si el archivo existe y se puede escribir. + +```golpecito +[[ -w ${archivo} ]] +``` + +* Verdadero si el archivo existe y es ejecutable. + +```golpecito +[[ -x ${archivo} ]] +``` + +* Verdadero si el archivo existe y es un enlace simbólico. + +```golpecito +[[ -L ${archivo} ]] +``` + +## Expresiones de cadena + +* Verdadero si la variable de shell varname está configurada (se le ha asignado un valor). + +```golpecito +[[ -v ${varname} ]] +``` + +Verdadero si la longitud de la cadena es cero. + +```golpecito +[[ -z ${cadena} ]] +``` + +Verdadero si la longitud de la cadena es distinta de cero. + +```golpecito +[[ -n ${cadena} ]] +``` + +* Verdadero si las cadenas son iguales. `=` debe usarse con el comando de prueba para la conformidad con POSIX. Cuando se usa con el comando `[[`, realiza la coincidencia de patrones como se describe arriba (Comandos compuestos). + +```golpecito +[[ ${cadena1} == ${cadena2} ]] +``` + +* Verdadero si las cadenas no son iguales. + +```golpecito +[[ ${string1} != ${string2} ]] +``` + +* Verdadero si cadena1 ordena lexicográficamente antes de cadena2. + +```golpecito +[[ ${cadena1} < ${cadena2} ]] +``` + +* Verdadero si cadena1 ordena lexicográficamente después de cadena2. + +```golpecito +[[ ${string1} > ${string2} ]] +``` + +## Operadores aritméticos + +* Devuelve verdadero si los números son **iguales** + +```golpecito +[[ ${arg1} -eq ${arg2} ]] +``` + +* Devuelve verdadero si los números **no son iguales** + +```golpecito +[[ ${arg1} -ne ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **menor que** arg2 + +```golpecito +[[ ${arg1} -lt ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **menor o igual** arg2 + +```golpecito +[[ ${arg1} -le ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **mayor que** arg2 + +```golpecito +[[ ${arg1} -gt ${arg2} ]] +``` + +* Devuelve verdadero si arg1 es **mayor o igual** arg2 + +```golpecito +[[ ${arg1} -ge ${arg2} ]] +``` + +Como nota al margen, arg1 y arg2 pueden ser números enteros positivos o negativos. + +Al igual que con otros lenguajes de programación, puedes usar las condiciones `Y` y `O`: + +```golpecito +[[ test_case_1 ]] && [[ test_case_2 ]] # Y +[[ test_case_1 ]] || [[ test_case_2 ]] # O +``` + +## Operadores de estado de salida + +* devuelve verdadero si el comando fue exitoso sin ningún error + +```golpecito +ps -ecuación 0 ]] +``` + +* devuelve verdadero si el comando no tuvo éxito o tuvo errores + +```golpecito +ps -gt 0 ]] +``` \ No newline at end of file diff --git a/ebook/sp/assets/content/010-bash-conditionals.md b/ebook/sp/assets/content/010-bash-conditionals.md new file mode 100644 index 0000000..0fdf71f --- /dev/null +++ b/ebook/sp/assets/content/010-bash-conditionals.md @@ -0,0 +1,181 @@ +# Condicionales de bash + +En la última sección, cubrimos algunas de las expresiones condicionales más populares. Ahora podemos usarlos con declaraciones condicionales estándar como declaraciones `if`, `if-else` y `switch case`. + +## Si declaración + +El formato de una declaración "if" en Bash es el siguiente: + +```golpecito +si [[ alguna_prueba ]] +entonces + +fi +``` + +Aquí hay un ejemplo rápido que le pedirá que ingrese su nombre en caso de que lo haya dejado vacío: + +```golpecito +#!/bin/bash + +# Ejemplo de declaración Bash if + +leer -p "¿Cuál es tu nombre?" nombre + +si [[ -z ${nombre} ]] +entonces + echo "¡Por favor ingresa tu nombre!" +fi +``` + +## Si no, declaración + +Con una declaración `if-else`, puede especificar una acción en caso de que la condición en la declaración `if` no coincida. Podemos combinar esto con las expresiones condicionales de la sección anterior de la siguiente manera: + +```golpecito +#!/bin/bash + +# Ejemplo de declaración Bash if + +leer -p "¿Cuál es tu nombre?" nombre + +si [[ -z ${nombre} ]] +entonces + echo "¡Por favor ingresa tu nombre!" +demás + echo "Hola ${nombre}" +fi +``` + +Puede utilizar la declaración if anterior con todas las expresiones condicionales de los capítulos anteriores: + +```golpecito +#!/bin/bash + +admin="devdojo" + +leer -p "¿Ingrese su nombre de usuario?" nombre de usuario + +# Comprobar si el nombre de usuario proporcionado es el administrador + +if [[ "${nombre de usuario}" == "${admin}" ]] ; entonces + echo "¡Tú eres el usuario administrador!" +demás + echo "¡NO eres el usuario administrador!" +fi +``` + +Aquí hay otro ejemplo de una declaración `if` que verificaría su `ID de usuario` actual y no le permitiría ejecutar el script como usuario `root`: + +```golpecito +#!/bin/bash + +si (( $EUID == 0 )); entonces + echo "Por favor no ejecutar como root" + salida +fi +``` + +Si coloca esto encima de su secuencia de comandos, se cerrará en caso de que el EUID sea 0 y no ejecutará el resto de la secuencia de comandos. Esto se discutió en [el foro de la comunidad DigitalOcean] (https://www.digitalocean.com/community/questions/how-to-check-if-running-as-root-in-a-bash-script). + +También puedes probar múltiples condiciones con una declaración "if". En este ejemplo queremos asegurarnos de que el usuario no sea ni el usuario administrador ni el usuario root para garantizar que el script no pueda causar demasiado daño. Usaremos el operador `o` en este ejemplo, marcado con `||`. Esto significa que cualquiera de las condiciones debe ser cierta. Si usáramos el operador `y` de `&&` entonces ambas condiciones tendrían que ser verdaderas. + +```golpecito +#!/bin/bash + +admin="devdojo" + +leer -p "¿Ingrese su nombre de usuario?" nombre de usuario + +# Comprobar si el nombre de usuario proporcionado es el administrador + +if [[ "${nombre de usuario}" != "${admin}" ]] || [[ $EUID != 0 ]] ; entonces + echo "Usted no es el administrador ni el usuario root, ¡pero tenga cuidado!" +demás + echo "¡Tú eres el usuario administrador! ¡Esto podría ser muy destructivo!" +fi +``` + +Si tiene varias condiciones y escenarios, puede usar la declaración "elif" con las declaraciones "if" y "else". + +```golpecito +#!/bin/bash + +leer -p "Ingrese un número: " num + +si [[ $num -gt 0 ]] ; entonces + echo "El número es positivo" +elif [[ $num -lt 0 ]] ; entonces + echo "El número es negativo" +demás + echo "El número es 0" +fi +``` + +## Cambiar declaraciones de caso + +Como en otros lenguajes de programación, puede utilizar una declaración "case" para simplificar condicionales complejos cuando hay varias opciones diferentes. Entonces, en lugar de usar algunas declaraciones `if` y `if-else`, podría usar una sola declaración `case`. + +La sintaxis de la declaración Bash `case` se ve así: + +```golpecito +caso $alguna_variable en + + patrón_1) + comandos + ;; + + patrón_2| patrón_3) + comandos + ;; + + *) + comandos predeterminados + ;; +esac +``` + +Un rápido resumen de la estructura: + +* Todas las declaraciones "case" comienzan con la palabra clave "case". +* En la misma línea que la palabra clave `case`, debe especificar una variable o una expresión seguida de la palabra clave `in`. +* Después de eso, tienes tus patrones `case`, donde necesitas usar `)` para identificar el final del patrón. +* Puede especificar múltiples patrones divididos por una tubería: `|`. +* Después del patrón, especifica los comandos que le gustaría que se ejecuten en caso de que el patrón coincida con la variable o la expresión que haya especificado. +* Todas las cláusulas deben terminar agregando `;;` al final. +* Puede tener una declaración predeterminada agregando un `*` como patrón. +* Para cerrar la declaración `case`, use la palabra clave `esac` (caso escrito al revés). + +A continuación se muestra un ejemplo de una declaración de "caso" de Bash: + +```golpecito +#!/bin/bash + +leer -p "Ingrese el nombre de la marca de su automóvil: " automóvil + +caso $car en + + tesla) + echo -n "La fábrica de automóviles de ${car} está en EE. UU." + ;; + + BMW | mercedes | Audi | Porsche) + echo -n "La fábrica de automóviles de ${car} está en Alemania". + ;; + + Toyota | Mazda | Mitsubishi | Subaru) + echo -n "La fábrica de automóviles de ${car} está en Japón". + ;; + + *) + echo -n "${car} es una marca de automóvil desconocida" + ;; + +esac +``` + +Con este script, le pedimos al usuario que ingrese el nombre de una marca de automóvil como Telsa, BMW, Mercedes, etc. + +Luego, con una declaración de "caso", verificamos el nombre de la marca y si coincide con alguno de nuestros patrones y, de ser así, imprimimos la ubicación de la fábrica. + +Si el nombre de la marca no coincide con ninguna de nuestras declaraciones de "caso", \ No newline at end of file diff --git a/ebook/sp/assets/content/011-bash-loops.md b/ebook/sp/assets/content/011-bash-loops.md new file mode 100644 index 0000000..4350a28 --- /dev/null +++ b/ebook/sp/assets/content/011-bash-loops.md @@ -0,0 +1,197 @@ +# Bucles de bash + +Como ocurre con cualquier otro idioma, los bucles son muy convenientes. Con Bash puedes usar bucles `for`, `` while` y `hasta`. + +## Para bucles + +Aquí está la estructura de un bucle for: + +```golpecito +para var en ${lista} +hacer + tus_comandos +hecho +``` + +Ejemplo: + +```golpecito +#!/bin/bash + +usuarios="devdojo bobby tony" + +para usuario en ${users} +hacer + eco "${usuario}" +hecho +``` + +Un resumen rápido del ejemplo: + +* Primero, especificamos una lista de usuarios y almacenamos el valor en una variable llamada `$usuarios`. +* Después de eso, iniciamos nuestro bucle `for` con la palabra clave `for`. +* Luego definimos una nueva variable que representaría cada elemento de la lista que le damos. En nuestro caso, definimos una variable llamada `usuario`, que representaría a cada usuario de la variable `$users`. +* Luego especificamos la palabra clave `in` seguida de nuestra lista que recorreremos. +* En la siguiente línea, usamos la palabra clave `do`, que indica qué haremos para cada iteración del bucle. +* Luego especificamos los comandos que queremos ejecutar. +* Finalmente, cerramos el ciclo con la palabra clave `done`. + +También puedes usar `for` para procesar una serie de números. Por ejemplo, aquí hay una forma de recorrer del 1 al 10: + +```golpecito +#!/bin/bash + +para número en {1..10} +hacer + eco ${numero} +hecho +``` + +## bucles while + +La estructura de un bucle while es bastante similar a la del bucle "for": + +```golpecito +mientras [tu_condición] +hacer + tus_comandos +hecho +``` + +A continuación se muestra un ejemplo de un bucle " while ": + +```golpecito +#!/bin/bash + +contador=1 +mientras [[ $counter -le 10 ]] +hacer + eco $ contador + ((contra++)) +hecho +``` + +Primero, especificamos una variable de contador y la configuramos en `1`, luego, dentro del bucle, agregamos un contador usando esta declaración aquí: `((counter++))`. De esa manera, nos aseguramos de que el ciclo se ejecute solo 10 veces y no para siempre. El ciclo se completará tan pronto como el contador llegue a 10, ya que esto es lo que hemos establecido como condición: ` while [[ $counter -le 10 ]]`. + +Creemos un script que le pregunte al usuario su nombre y no permita una entrada vacía: + +```golpecito +#!/bin/bash + +leer -p "¿Cuál es tu nombre?" nombre + +mientras [[ -z ${nombre} ]] +hacer + echo "Su nombre no puede estar en blanco. ¡Ingrese un nombre válido!" + leer -p "¿Ingresa tu nombre otra vez?" nombre +hecho + +echo "Hola ${nombre}" +``` + +Ahora, si ejecuta lo anterior y simplemente presiona Intro sin proporcionar información, el bucle se ejecutará nuevamente y le pedirá su nombre una y otra vez hasta que realmente proporcione alguna información. + +## Hasta bucles + +La diferencia entre los bucles `hasta` y `` while` es que el bucle `hasta` ejecutará los comandos dentro del bucle hasta que la condición se vuelva verdadera. + +Estructura: + +```golpecito +hasta [[ tu_condición ]] +hacer + tus_comandos +hecho +``` + +Ejemplo: + +```golpecito +#!/bin/bash + +contar=1 +hasta [[ $count -gt 10 ]] +hacer + eco $ cuenta + ((cuenta++)) +hecho +``` + +## Continuar y romper +Al igual que con otros lenguajes, también puedes usar "continuar" y "romper" con tus scripts bash: + +* `continue` le dice a su script bash que detenga la iteración actual del bucle y comience la siguiente iteración. + +La sintaxis de la declaración de continuación es la siguiente: + +```golpecito +continuar [n] +``` + +El argumento [n] es opcional y puede ser mayor o igual a 1. Cuando se proporciona [n], se reanuda el enésimo bucle envolvente. continuar 1 es equivalente a continuar. + +```golpecito +#!/bin/bash + +para yo en 1 2 3 4 5 +hacer + si [[ $i –eq 2 ]] + entonces + echo "omitiendo el número 2" + continuar + fi + echo "i es igual a $i" +hecho +``` + +También podemos usar el comando continuar de manera similar al comando romper para controlar múltiples bucles. + +* `break` le dice a su script bash que finalice el ciclo de inmediato. + +La sintaxis de la declaración de interrupción toma la siguiente forma: + +```golpecito +descanso [n] +``` +[n] es un argumento opcional y debe ser mayor o igual a 1. Cuando se proporciona [n], se sale del enésimo bucle circundante. break 1 es equivalente a break. + +Ejemplo: + +```golpecito +#!/bin/bash + +número=1 +mientras [[ $num –lt 10 ]] +hacer + si [[ $num –eq 5 ]] + entonces + romper + fi + ((núm++)) +hecho +echo "Bucle completado" +``` + +También podemos usar el comando break con múltiples bucles. Si queremos salir del bucle de trabajo actual, ya sea interno o externo, simplemente usamos break, pero si estamos en el bucle interno y queremos salir del bucle externo, usamos break 2. + +Ejemplo: + +```golpecito +#!/bin/bash + +para (( a = 1; a < 10; a++ )) +hacer + echo "bucle externo: $a" + para (( b = 1; b < 100; b++ )) + hacer + si [[ $b –gt 5 ]] + entonces + descanso 2 + fi + echo "Bucle interno: $b " + hecho +hecho +``` + +El script bash comenzará con a=1 y se moverá al bucle interno y cuando llegue a b=5, romperá el bucle externo. +Podemos usar break only en lugar de break 2, para romper el bucle interno y ver cómo afecta la salida. \ No newline at end of file diff --git a/ebook/sp/assets/content/012-bash-functions.md b/ebook/sp/assets/content/012-bash-functions.md new file mode 100644 index 0000000..fc2bd3d --- /dev/null +++ b/ebook/sp/assets/content/012-bash-functions.md @@ -0,0 +1,66 @@ +# Funciones de bash + +Las funciones son una excelente manera de reutilizar código. La estructura de una función en bash es bastante similar a la de la mayoría de los lenguajes: + +```golpecito +función nombre_función() { + tus_comandos +} +``` + +También puedes omitir la palabra clave `function` al principio, lo que también funcionaría: + +```golpecito +nombre de la función() { + tus_comandos +} +``` + +Prefiero ponerlo allí para una mejor legibilidad. Pero es una cuestión de preferencia personal. + +Ejemplo de "¡Hola mundo!" función: + +```golpecito +#!/bin/bash + +función hola() { + echo "¡Función Hola Mundo!" +} + +Hola +``` + +>{aviso} Una cosa a tener en cuenta es que no debes agregar paréntesis cuando llamas a la función. + +Pasar argumentos a una función funciona de la misma manera que pasar argumentos a un script: + +```golpecito +#!/bin/bash + +función hola() { + echo "¡Hola $1!" +} + +Hola DevDojo +``` + +Las funciones deben tener comentarios que mencionen la descripción, las variables globales, los argumentos, los resultados y los valores devueltos, si corresponde. + +```golpecito +####################################### +# Descripción: Función Hola +# Globales: +# Ninguno +# Argumentos: +# Argumento de entrada único +# Salidas: +# Valor del argumento de entrada +# Devoluciones: +# 0 si tiene éxito, distinto de cero en caso de error. +####################################### +función hola() { + echo "¡Hola $1!" +} +``` + +¡En los próximos capítulos usaremos mucho las funciones! \ No newline at end of file diff --git a/ebook/sp/assets/content/013-debugging-and-testing.md b/ebook/sp/assets/content/013-debugging-and-testing.md new file mode 100644 index 0000000..2a3a9cb --- /dev/null +++ b/ebook/sp/assets/content/013-debugging-and-testing.md @@ -0,0 +1,83 @@ +# Depuración, pruebas y atajos + +Para depurar sus scripts bash, puede usar `-x` al ejecutar sus scripts: + +```golpecito +bash -x ./tu_script.sh +``` + +O puede agregar `set -x` antes de la línea específica que desea depurar, `set -x` habilita un modo del shell donde todos los comandos ejecutados se imprimen en la terminal. + +Otra forma de probar tus scripts es utilizar esta fantástica herramienta aquí: + +[https://www.shellcheck.net/](https://www.shellcheck.net/) + +Simplemente copie y pegue su código en el cuadro de texto y la herramienta le dará algunas sugerencias sobre cómo puede mejorar su script. + +También puedes ejecutar la herramienta directamente en tu terminal: + +[https://github.com/koalaman/shellcheck](https://github.com/koalaman/shellcheck) + +Si te gusta la herramienta, asegúrate de destacarla en GitHub y contribuir. + +Como SysAdmin/DevOps, paso gran parte del día en la terminal. Estos son mis atajos favoritos que me ayudan a realizar tareas más rápido mientras escribo scripts Bash o simplemente mientras trabajo en la terminal. + +Los dos siguientes son particularmente útiles si tienes un comando muy largo. + +* Eliminar todo desde el cursor hasta el final de la línea: + +``` +Ctrl+k +``` + +* Eliminar todo desde el cursor hasta el inicio de la línea: + +``` +Ctrl + u +``` + +* Eliminar una palabra hacia atrás desde el cursor: + +``` +Ctrl + w +``` + +* Busca en tu historial hacia atrás. Este es probablemente el que más uso. Es realmente útil y acelera mucho mi flujo de trabajo: + +``` +Ctrl+r +``` + +* Limpiar la pantalla, uso esto en lugar de escribir el comando `clear`: + +``` +Ctrl + l +``` + +* Detiene la salida a la pantalla: + +``` +Ctrl + s +``` + +* Habilitar la salida a pantalla en caso de que previamente se detuviera con `Ctrl + s`: + +``` +Ctrl + q +``` + +* Terminar el comando actual + +``` +Ctrl+c +``` + +* Lanzar el comando actual al fondo: + +``` +Ctrl + z +``` + +Los uso regularmente todos los días y me ahorra mucho tiempo. + +Si cree que me he perdido algo, no dude en unirse a la discusión en [el foro de la comunidad de DigitalOcean] (https://www.digitalocean.com/community/questions/what-are-your-favorite-bash-shortcuts). diff --git a/ebook/sp/assets/content/014-creating-custom-bash-commands.md b/ebook/sp/assets/content/014-creating-custom-bash-commands.md new file mode 100644 index 0000000..a036092 --- /dev/null +++ b/ebook/sp/assets/content/014-creating-custom-bash-commands.md @@ -0,0 +1,83 @@ +# Creando comandos bash personalizados + +Como desarrollador o administrador de sistemas, es posible que tengas que pasar mucho tiempo en tu terminal. Siempre trato de buscar formas de optimizar las tareas repetitivas. + +Una forma de hacerlo es escribir scripts bash cortos o crear comandos personalizados, también conocidos como alias. Por ejemplo, en lugar de escribir un comando muy largo cada vez, puedes simplemente crear un atajo para él. + +## Ejemplo + +Comencemos con el siguiente escenario: como administrador del sistema, es posible que deba verificar las conexiones a su servidor web con bastante frecuencia, por lo que usaré el comando `netstat` como ejemplo. + +Lo que normalmente haría cuando accedo a un servidor que tiene problemas con las conexiones al puerto 80 o 443 es verificar si hay algún servicio escuchando en esos puertos y la cantidad de conexiones a los puertos. + +El siguiente comando `netstat` nos mostraría cuántas conexiones TCP en los puertos 80 y 443 tenemos actualmente: + +```golpecito +planta netstat | grep '80\|443' | grep -v ESCUCHAR | baño -l +``` +Este es un comando bastante largo, por lo que escribirlo cada vez puede llevar mucho tiempo a largo plazo, especialmente cuando desea obtener esa información rápidamente. + +Para evitar eso, podemos crear un alias, de modo que en lugar de escribir el comando completo, podríamos simplemente escribir un comando corto. Por ejemplo, digamos que queremos poder escribir "conn" (abreviatura de conexiones) y obtener la misma información. Todo lo que necesitamos hacer en este caso es ejecutar el siguiente comando: + +```golpecito +alias conn="netstat -plant | grep '80\|443' | grep -v ESCUCHAR | wc -l" +``` + +De esa manera estamos creando un alias llamado "conn" que esencialmente sería un "atajo" para nuestro comando largo "netstat". Ahora, si ejecutas solo `conn`: + +```golpecito +conectar +``` + +Obtendría el mismo resultado que el comando largo `netstat`. +Puedes ser aún más creativo y agregar algunos mensajes informativos como este aquí: + +```golpecito +alias conn="echo 'Total de conexiones en los puertos 80 y 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Ahora, si ejecuta `conn`, obtendrá el siguiente resultado: + +```golpecito +Conexiones totales en el puerto 80 y 443: +12 +``` +Ahora, si cierra sesión y vuelve a iniciarla, su alias se perderá. En el siguiente paso verás cómo hacer que esto sea persistente. + +## Hacer que el cambio sea persistente + +Para que el cambio sea persistente, necesitamos agregar el comando `alias` en nuestro archivo de perfil de shell. + +De forma predeterminada en Ubuntu, este sería el archivo `~/.bashrc`; para otros sistemas operativos, este podría ser el archivo `~/.bash_profle`. Con tu editor de texto favorito abre el archivo: + +```golpecito +nano ~/.bashrc +``` + +Vaya al final y agregue lo siguiente: + +```golpecito +alias conn="echo 'Total de conexiones en los puertos 80 y 443:' ; netstat -plant | grep '80\|443' | grep -v LISTEN | wc -l" +``` + +Guarde y luego salga. + +De esa manera, incluso si cierra sesión y vuelve a iniciarla, su cambio persistirá y podrá ejecutar su comando bash personalizado. + +## Listado de todos los alias disponibles + +Para enumerar todos los alias disponibles para su shell actual, simplemente debe ejecutar el siguiente comando: + +```golpecito +alias +``` + +Esto sería útil en caso de que observe algún comportamiento extraño con algunos comandos. + +## Conclusión + +Esta es una forma de crear comandos bash personalizados o alias de bash. + +Por supuesto, podrías escribir un script bash y agregarlo dentro de tu carpeta `/usr/bin`, pero esto no funcionaría si no tienes acceso root o sudo, mientras que con alias puedes hacerlo sin necesidad. de acceso raíz. + +>{aviso} Esto se publicó inicialmente en [DevDojo.com](https://devdojo.com/bobbyiliev/how-to-create-custom-bash-commands) \ No newline at end of file diff --git a/ebook/sp/assets/content/015-writing-your-first-bash-script.md b/ebook/sp/assets/content/015-writing-your-first-bash-script.md new file mode 100644 index 0000000..83102b8 --- /dev/null +++ b/ebook/sp/assets/content/015-writing-your-first-bash-script.md @@ -0,0 +1,180 @@ +# Escribe tu primer script Bash + +¡Intentemos reunir lo que hemos aprendido hasta ahora y crear nuestro primer script Bash! + +## Planificando el guión + +Como ejemplo, escribiremos un script que recopilará información útil sobre nuestro servidor como: + +* Uso actual del disco +* Uso actual de la CPU +* Uso actual de RAM +* Verifique la versión exacta del Kernel + +Siéntase libre de ajustar el script agregando o eliminando funciones para que se ajuste a sus necesidades. + +## Escribiendo el guión + +Lo primero que debe hacer es crear un nuevo archivo con una extensión `.sh`. Crearé un archivo llamado `status.sh` ya que el script que crearemos nos dará el estado de nuestro servidor. + +Una vez que haya creado el archivo, ábralo con su editor de texto favorito. + +Como aprendimos en el capítulo 1, en la primera línea de nuestro script Bash debemos especificar el llamado [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)): + +```golpecito +#!/bin/bash +``` + +Todo lo que hace el shebang es indicarle al sistema operativo que ejecute el script con el ejecutable /bin/bash. + +## Agregar comentarios + +A continuación, como se discutió en el capítulo 6, comencemos agregando algunos comentarios para que la gente pueda entender fácilmente para qué se usa el script. Para hacerlo justo después del shebang, simplemente puede agregar lo siguiente: + +```golpecito +#!/bin/bash + +# Script que devuelve el estado actual del servidor +``` + +## Agregando tu primera variable + +Luego sigamos adelante y apliquemos lo que hemos aprendido en el capítulo 4 y agreguemos algunas variables que quizás queramos usar en todo el guión. + +Para asignar un valor a una variable en bash, solo tienes que usar el signo `=`. Por ejemplo, almacenemos el nombre de host de nuestro servidor en una variable para poder usarlo más tarde: + +```golpecito +nombre_servidor=$(nombre de host) +``` + +Al usar `$()` le decimos a bash que realmente interprete el comando y luego asigne el valor a nuestra variable. + +Ahora, si hiciéramos eco de la variable, veríamos el nombre de host actual: + +```golpecito +echo $nombre_servidor +``` + +## Agregando tu primera función + +Como ya sabes después de leer el capítulo 12, para crear una función en bash necesitas usar la siguiente estructura: + +```golpecito +función nombre_función() { + tus_comandos +} +``` + +Creemos una función que devuelva el uso de memoria actual en nuestro servidor: + +```golpecito +función memoria_check() { + eco "" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "" +} +``` + +Desglose rápido de la función: + +* `function Memory_check() {` - así es como definimos la función +* `echo ""` - aquí simplemente imprimimos una nueva línea +* `echo "El uso actual de memoria en ${server_name} es: "` - aquí imprimimos un pequeño mensaje y la variable `$server_name` +* `}` - finalmente así es como cerramos la función + +Luego una vez definida la función, para llamarla basta con utilizar el nombre de la función: + +```golpecito +# Definir la función +función memoria_check() { + eco "" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "" +} + +# Llamar a la función +comprobación de memoria +``` + +## Desafío de agregar más funciones + +Antes de comprobar la solución, te reto a que uses la función anterior y escribas algunas funciones tú mismo. + +Las funciones deben hacer lo siguiente: + +* Uso actual del disco +* Uso actual de la CPU +* Uso actual de RAM +* Verifique la versión exacta del Kernel + +No dude en utilizar Google si no está seguro de qué comandos necesita utilizar para obtener esa información. + +Una vez que esté listo, no dude en desplazarse hacia abajo y comprobar cómo lo hemos hecho y comparar los resultados. + +¡Tenga en cuenta que existen varias formas correctas de hacerlo! + +## El guión de muestra + +Así es como se vería el resultado final: + +```golpecito +#!/bin/bash + +## +# Script BASH que verifica: +# - Uso de memoria +# - carga de CPU +# - Número de conexiones TCP +# - Versión del núcleo +## + +nombre_servidor=$(nombre de host) + +función memoria_check() { + eco "" +echo "El uso de memoria en ${server_name} es: " +libre -h +eco "" +} + +función cpu_check() { + eco "" +echo "La carga de CPU en ${server_name} es: " + eco "" +tiempo de actividad + eco "" +} + +función tcp_check() { + eco "" +echo "Conexiones TCP en ${server_name}: " + eco "" +gato /proc/net/tcp | baño -l + eco "" +} + +función kernel_check() { + eco "" +echo "La versión del kernel en ${server_name} es: " +eco "" +uname -r + eco "" +} + +función all_checks() { +comprobación de memoria +CPU_check +tcp_check +kernel_check +} + +todos_controles +``` + +## Conclusión + +¡Las secuencias de comandos Bash son increíbles! No importa si es un ingeniero, desarrollador o simplemente un entusiasta de Linux en DevOps/SysOps, puede usar scripts Bash para combinar diferentes comandos de Linux y automatizar tareas diarias aburridas y repetitivas, para que pueda concentrarse en cosas más productivas y divertidas. + +>{aviso} Esto se publicó inicialmente en [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) \ No newline at end of file diff --git a/ebook/sp/assets/content/016-creating-an-interactive-menu-in-bash.md b/ebook/sp/assets/content/016-creating-an-interactive-menu-in-bash.md new file mode 100644 index 0000000..83102b8 --- /dev/null +++ b/ebook/sp/assets/content/016-creating-an-interactive-menu-in-bash.md @@ -0,0 +1,180 @@ +# Escribe tu primer script Bash + +¡Intentemos reunir lo que hemos aprendido hasta ahora y crear nuestro primer script Bash! + +## Planificando el guión + +Como ejemplo, escribiremos un script que recopilará información útil sobre nuestro servidor como: + +* Uso actual del disco +* Uso actual de la CPU +* Uso actual de RAM +* Verifique la versión exacta del Kernel + +Siéntase libre de ajustar el script agregando o eliminando funciones para que se ajuste a sus necesidades. + +## Escribiendo el guión + +Lo primero que debe hacer es crear un nuevo archivo con una extensión `.sh`. Crearé un archivo llamado `status.sh` ya que el script que crearemos nos dará el estado de nuestro servidor. + +Una vez que haya creado el archivo, ábralo con su editor de texto favorito. + +Como aprendimos en el capítulo 1, en la primera línea de nuestro script Bash debemos especificar el llamado [Shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)): + +```golpecito +#!/bin/bash +``` + +Todo lo que hace el shebang es indicarle al sistema operativo que ejecute el script con el ejecutable /bin/bash. + +## Agregar comentarios + +A continuación, como se discutió en el capítulo 6, comencemos agregando algunos comentarios para que la gente pueda entender fácilmente para qué se usa el script. Para hacerlo justo después del shebang, simplemente puede agregar lo siguiente: + +```golpecito +#!/bin/bash + +# Script que devuelve el estado actual del servidor +``` + +## Agregando tu primera variable + +Luego sigamos adelante y apliquemos lo que hemos aprendido en el capítulo 4 y agreguemos algunas variables que quizás queramos usar en todo el guión. + +Para asignar un valor a una variable en bash, solo tienes que usar el signo `=`. Por ejemplo, almacenemos el nombre de host de nuestro servidor en una variable para poder usarlo más tarde: + +```golpecito +nombre_servidor=$(nombre de host) +``` + +Al usar `$()` le decimos a bash que realmente interprete el comando y luego asigne el valor a nuestra variable. + +Ahora, si hiciéramos eco de la variable, veríamos el nombre de host actual: + +```golpecito +echo $nombre_servidor +``` + +## Agregando tu primera función + +Como ya sabes después de leer el capítulo 12, para crear una función en bash necesitas usar la siguiente estructura: + +```golpecito +función nombre_función() { + tus_comandos +} +``` + +Creemos una función que devuelva el uso de memoria actual en nuestro servidor: + +```golpecito +función memoria_check() { + eco "" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "" +} +``` + +Desglose rápido de la función: + +* `function Memory_check() {` - así es como definimos la función +* `echo ""` - aquí simplemente imprimimos una nueva línea +* `echo "El uso actual de memoria en ${server_name} es: "` - aquí imprimimos un pequeño mensaje y la variable `$server_name` +* `}` - finalmente así es como cerramos la función + +Luego una vez definida la función, para llamarla basta con utilizar el nombre de la función: + +```golpecito +# Definir la función +función memoria_check() { + eco "" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "" +} + +# Llamar a la función +comprobación de memoria +``` + +## Desafío de agregar más funciones + +Antes de comprobar la solución, te reto a que uses la función anterior y escribas algunas funciones tú mismo. + +Las funciones deben hacer lo siguiente: + +* Uso actual del disco +* Uso actual de la CPU +* Uso actual de RAM +* Verifique la versión exacta del Kernel + +No dude en utilizar Google si no está seguro de qué comandos necesita utilizar para obtener esa información. + +Una vez que esté listo, no dude en desplazarse hacia abajo y comprobar cómo lo hemos hecho y comparar los resultados. + +¡Tenga en cuenta que existen varias formas correctas de hacerlo! + +## El guión de muestra + +Así es como se vería el resultado final: + +```golpecito +#!/bin/bash + +## +# Script BASH que verifica: +# - Uso de memoria +# - carga de CPU +# - Número de conexiones TCP +# - Versión del núcleo +## + +nombre_servidor=$(nombre de host) + +función memoria_check() { + eco "" +echo "El uso de memoria en ${server_name} es: " +libre -h +eco "" +} + +función cpu_check() { + eco "" +echo "La carga de CPU en ${server_name} es: " + eco "" +tiempo de actividad + eco "" +} + +función tcp_check() { + eco "" +echo "Conexiones TCP en ${server_name}: " + eco "" +gato /proc/net/tcp | baño -l + eco "" +} + +función kernel_check() { + eco "" +echo "La versión del kernel en ${server_name} es: " +eco "" +uname -r + eco "" +} + +función all_checks() { +comprobación de memoria +CPU_check +tcp_check +kernel_check +} + +todos_controles +``` + +## Conclusión + +¡Las secuencias de comandos Bash son increíbles! No importa si es un ingeniero, desarrollador o simplemente un entusiasta de Linux en DevOps/SysOps, puede usar scripts Bash para combinar diferentes comandos de Linux y automatizar tareas diarias aburridas y repetitivas, para que pueda concentrarse en cosas más productivas y divertidas. + +>{aviso} Esto se publicó inicialmente en [DevDojo.com](https://devdojo.com/bobbyiliev/introduction-to-bash-scripting) \ No newline at end of file diff --git a/ebook/sp/assets/content/017-executing-bash-script-on-multiple-remote-server.md b/ebook/sp/assets/content/017-executing-bash-script-on-multiple-remote-server.md new file mode 100644 index 0000000..d1db21f --- /dev/null +++ b/ebook/sp/assets/content/017-executing-bash-script-on-multiple-remote-server.md @@ -0,0 +1,129 @@ +# Ejecutar scripts BASH en múltiples servidores remotos + +Cualquier comando que pueda ejecutar desde la línea de comandos se puede utilizar en un script bash. Los scripts se utilizan para ejecutar una serie de comandos. Bash está disponible de forma predeterminada en los sistemas operativos Linux y macOS. + +Tengamos un escenario hipotético en el que necesita ejecutar un script BASH en varios servidores remotos, pero no desea copiar manualmente el script en cada servidor, luego volver a iniciar sesión en cada servidor individualmente y solo luego ejecutar el script. + +Por supuesto, podrías usar una herramienta como Ansible, ¡pero aprendamos cómo hacerlo con Bash! + +## Requisitos previos + +Para este ejemplo usaré 3 servidores Ubuntu remotos implementados en DigitalOcean. Si aún no tiene una cuenta de Digital Ocean, puede registrarse en DigitalOcean y obtener $100 de crédito gratis a través de este enlace de referencia aquí: + +[https://m.do.co/c/2a9bba940f39](https://m.do.co/c/2a9bba940f39) + +Una vez que tenga lista su cuenta de Digital Ocean, continúe e implemente 3 gotas. + +Seguí adelante y creé 3 servidores Ubuntu: + +![Servidores DigitalOcean Ubuntu](https://imgur.com/09xmq41.png) + +Pondré las IP de esos servidores en un archivo `servers.txt` que usaría para realizar un bucle con nuestro script Bash. + +Si eres nuevo en DigitalOcean, puedes seguir los pasos sobre cómo crear un Droplet aquí: + +* [Cómo crear un droplet desde el panel de control de DigitalOcean](https://www.digitalocean.com/docs/droplets/how-to/create/) + +También puede seguir los pasos de este video aquí sobre cómo realizar la configuración inicial del servidor: + +* [Cómo realizar la configuración inicial del servidor con Ubuntu](https://youtu.be/7NL2_4HIgKU) + +O mejor aún, puedes seguir este artículo aquí sobre cómo automatizar la configuración inicial de tu servidor con Bash: + +[Automatización de la configuración inicial del servidor con Ubuntu 18.04 con Bash](https://www.digitalocean.com/community/tutorials/automating-initial-server-setup-with-ubuntu-18-04) + +Con los 3 nuevos servidores instalados, podemos seguir adelante y concentrarnos en ejecutar nuestro script Bash en todos ellos con un solo comando. + +## El script BASH + +Reutilizaré el script de demostración del capítulo anterior con algunos ligeros cambios. Simplemente ejecuta algunas comprobaciones como el uso actual de la memoria, el uso actual de la CPU, la cantidad de conexiones TCP y la versión del kernel. + +```golpecito +#!/bin/bash + +## +# Script BASH que verifica lo siguiente: +# - Uso de memoria +# - carga de CPU +# - Número de conexiones TCP +# - Versión del núcleo +## + +## +# Comprobación de memoria +## +nombre_servidor=$(nombre de host) + +función memoria_check() { + eco "#######" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "#######" +} + + +función cpu_check() { + eco "#######" +echo "La carga actual de CPU en ${server_name} es: " + eco "" +tiempo de actividad + eco "#######" +} + +función tcp_check() { + eco "#######" +echo "Total de conexiones TCP en ${server_name}: " + eco "" +gato /proc/net/tcp | baño -l + eco "#######" +} + +función kernel_check() { + eco "#######" +echo "La versión exacta del kernel en ${server_name} es: " +eco "" +uname -r + eco "#######" +} + +función all_checks() { +comprobación de memoria +CPU_check +tcp_check +kernel_check +} + +todos_controles +``` + +Copie el código a continuación y agréguelo en un archivo llamado `remote_check.sh`. También puede obtener el script desde [aquí](https://devdojo.com/bobbyiliev/executing-bash-script-on-multiple-remote-server). + +## Ejecutando el script en todos los servidores + +Ahora que tenemos el script y los servidores listos y que hemos agregado esos servidores en nuestro archivo servers.txt, podemos ejecutar el siguiente comando para recorrer todos los servidores y ejecutar el script de forma remota sin tener que copiar el script a cada servidor y conectarse individualmente a cada servidor. + +```golpecito +para el servidor en $(cat servers.txt); haga ssh your_user@${server} 'bash -s' < ./remote_check.sh; hecho +``` + +Lo que hace este bucle for es recorrer cada servidor en el archivo servers.txt y luego ejecuta el siguiente comando para cada elemento de la lista: + +```golpecito +ssh tu_usuario@la_ip_servidor 'bash -s' < ./remote_check.sh +``` + +Obtendría el siguiente resultado: + +![Ejecutando script bash en múltiples servidores remotos](https://imgur.com/B1AmhUP.png) + +## Conclusión + +Este es solo un ejemplo realmente simple de cómo ejecutar un script simple en múltiples servidores sin tener que copiar el script en cada servidor y sin tener que acceder a los servidores individualmente. + +Por supuesto, podrías ejecutar un script mucho más complejo y en muchos más servidores. + +Si está interesado en la automatización, le recomendaría consultar la página de recursos de Ansible en el sitio web de DigitalOcean: + +[Recursos de Ansible](https://www.digitalocean.com/community/tags/ansible) + +>{aviso} Este contenido se publicó inicialmente en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) \ No newline at end of file diff --git a/ebook/sp/assets/content/018-working-with-json-in-bash-using-jq.md b/ebook/sp/assets/content/018-working-with-json-in-bash-using-jq.md new file mode 100644 index 0000000..d1db21f --- /dev/null +++ b/ebook/sp/assets/content/018-working-with-json-in-bash-using-jq.md @@ -0,0 +1,129 @@ +# Ejecutar scripts BASH en múltiples servidores remotos + +Cualquier comando que pueda ejecutar desde la línea de comandos se puede utilizar en un script bash. Los scripts se utilizan para ejecutar una serie de comandos. Bash está disponible de forma predeterminada en los sistemas operativos Linux y macOS. + +Tengamos un escenario hipotético en el que necesita ejecutar un script BASH en varios servidores remotos, pero no desea copiar manualmente el script en cada servidor, luego volver a iniciar sesión en cada servidor individualmente y solo luego ejecutar el script. + +Por supuesto, podrías usar una herramienta como Ansible, ¡pero aprendamos cómo hacerlo con Bash! + +## Requisitos previos + +Para este ejemplo usaré 3 servidores Ubuntu remotos implementados en DigitalOcean. Si aún no tiene una cuenta de Digital Ocean, puede registrarse en DigitalOcean y obtener $100 de crédito gratis a través de este enlace de referencia aquí: + +[https://m.do.co/c/2a9bba940f39](https://m.do.co/c/2a9bba940f39) + +Una vez que tenga lista su cuenta de Digital Ocean, continúe e implemente 3 gotas. + +Seguí adelante y creé 3 servidores Ubuntu: + +![Servidores DigitalOcean Ubuntu](https://imgur.com/09xmq41.png) + +Pondré las IP de esos servidores en un archivo `servers.txt` que usaría para realizar un bucle con nuestro script Bash. + +Si eres nuevo en DigitalOcean, puedes seguir los pasos sobre cómo crear un Droplet aquí: + +* [Cómo crear un droplet desde el panel de control de DigitalOcean](https://www.digitalocean.com/docs/droplets/how-to/create/) + +También puede seguir los pasos de este video aquí sobre cómo realizar la configuración inicial del servidor: + +* [Cómo realizar la configuración inicial del servidor con Ubuntu](https://youtu.be/7NL2_4HIgKU) + +O mejor aún, puedes seguir este artículo aquí sobre cómo automatizar la configuración inicial de tu servidor con Bash: + +[Automatización de la configuración inicial del servidor con Ubuntu 18.04 con Bash](https://www.digitalocean.com/community/tutorials/automating-initial-server-setup-with-ubuntu-18-04) + +Con los 3 nuevos servidores instalados, podemos seguir adelante y concentrarnos en ejecutar nuestro script Bash en todos ellos con un solo comando. + +## El script BASH + +Reutilizaré el script de demostración del capítulo anterior con algunos ligeros cambios. Simplemente ejecuta algunas comprobaciones como el uso actual de la memoria, el uso actual de la CPU, la cantidad de conexiones TCP y la versión del kernel. + +```golpecito +#!/bin/bash + +## +# Script BASH que verifica lo siguiente: +# - Uso de memoria +# - carga de CPU +# - Número de conexiones TCP +# - Versión del núcleo +## + +## +# Comprobación de memoria +## +nombre_servidor=$(nombre de host) + +función memoria_check() { + eco "#######" +echo "El uso actual de memoria en ${server_name} es: " +libre -h +eco "#######" +} + + +función cpu_check() { + eco "#######" +echo "La carga actual de CPU en ${server_name} es: " + eco "" +tiempo de actividad + eco "#######" +} + +función tcp_check() { + eco "#######" +echo "Total de conexiones TCP en ${server_name}: " + eco "" +gato /proc/net/tcp | baño -l + eco "#######" +} + +función kernel_check() { + eco "#######" +echo "La versión exacta del kernel en ${server_name} es: " +eco "" +uname -r + eco "#######" +} + +función all_checks() { +comprobación de memoria +CPU_check +tcp_check +kernel_check +} + +todos_controles +``` + +Copie el código a continuación y agréguelo en un archivo llamado `remote_check.sh`. También puede obtener el script desde [aquí](https://devdojo.com/bobbyiliev/executing-bash-script-on-multiple-remote-server). + +## Ejecutando el script en todos los servidores + +Ahora que tenemos el script y los servidores listos y que hemos agregado esos servidores en nuestro archivo servers.txt, podemos ejecutar el siguiente comando para recorrer todos los servidores y ejecutar el script de forma remota sin tener que copiar el script a cada servidor y conectarse individualmente a cada servidor. + +```golpecito +para el servidor en $(cat servers.txt); haga ssh your_user@${server} 'bash -s' < ./remote_check.sh; hecho +``` + +Lo que hace este bucle for es recorrer cada servidor en el archivo servers.txt y luego ejecuta el siguiente comando para cada elemento de la lista: + +```golpecito +ssh tu_usuario@la_ip_servidor 'bash -s' < ./remote_check.sh +``` + +Obtendría el siguiente resultado: + +![Ejecutando script bash en múltiples servidores remotos](https://imgur.com/B1AmhUP.png) + +## Conclusión + +Este es solo un ejemplo realmente simple de cómo ejecutar un script simple en múltiples servidores sin tener que copiar el script en cada servidor y sin tener que acceder a los servidores individualmente. + +Por supuesto, podrías ejecutar un script mucho más complejo y en muchos más servidores. + +Si está interesado en la automatización, le recomendaría consultar la página de recursos de Ansible en el sitio web de DigitalOcean: + +[Recursos de Ansible](https://www.digitalocean.com/community/tags/ansible) + +>{aviso} Este contenido se publicó inicialmente en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) \ No newline at end of file diff --git a/ebook/sp/assets/content/019-working-with-cloudflare-api-with-bash.md b/ebook/sp/assets/content/019-working-with-cloudflare-api-with-bash.md new file mode 100644 index 0000000..02bf1c4 --- /dev/null +++ b/ebook/sp/assets/content/019-working-with-cloudflare-api-with-bash.md @@ -0,0 +1,104 @@ +# Trabajar con la API de Cloudflare con Bash + +Alojo todos mis sitios web en **DigitalOcean** Droplets y también uso Cloudflare como mi proveedor de CDN. Uno de los beneficios de usar Cloudflare es que reduce el tráfico general hacia su usuario y también oculta la dirección IP real de su servidor detrás de su CDN. + +Mi característica favorita de Cloudflare es su protección DDoS gratuita. Ha salvado mis servidores varias veces de diferentes ataques DDoS. Tienen una API interesante que puedes usar para habilitar y deshabilitar su protección DDoS fácilmente. + +¡Este capítulo va a ser un ejercicio! ¡Te reto a que sigas adelante y escribas un breve script bash que habilite y deshabilite la protección DDoS de Cloudflare para tu servidor automáticamente si es necesario! + +## Requisitos previos + +Antes de seguir esta guía aquí, configure su cuenta de Cloudflare y prepare su sitio web. Si no está seguro de cómo hacerlo, puede seguir estos pasos aquí: [Cree una cuenta de Cloudflare y agregue un sitio web](https://support.cloudflare.com/hc/en-us/articles/201720164-Step-2 -Crear-una-cuenta-de-Cloudflare-y-agregar-un-sitio-web). + +Una vez que tenga su cuenta de Cloudflare, asegúrese de obtener la siguiente información: + +* Una cuenta de Cloudflare +* Clave API de Cloudflare +* ID de zona de Cloudflare + +Además, asegúrese de que curl esté instalado en su servidor: + +```golpecito +rizo --versión +``` + +Si curl no está instalado, debe ejecutar lo siguiente: + +* Para RedHat/CentO: + +```golpecito +mmm instalar curl +``` + +* Para Debian/Ubuntu + +```golpecito +apt-get instalar curl +``` + +## Desafío: requisitos del guión + +El script necesita monitorear el uso de la CPU en su servidor y, si el uso de la CPU aumenta según el número de vCPU, habilitará la protección DDoS de Cloudflare automáticamente a través de la API de Cloudflare. + +Las principales características del guión deben ser: + +* Comprueba la carga de la CPU del script en el servidor. +* En caso de un pico de CPU, el script activa una llamada API a Cloudflare y habilita la función de protección DDoS para la zona especificada. +* Después de que la carga de la CPU vuelva a la normalidad, el script desactivará la opción "Estoy bajo ataque" y la restablecerá a la normalidad. + +## Guión de ejemplo + +Ya he preparado un script de demostración que podrías utilizar como referencia. ¡Pero te animo a que primero intentes escribir el guión tú mismo y solo después le eches un vistazo al mío! + +Para descargar el script simplemente ejecute el siguiente comando: + +```golpecito +wget https://raw.githubusercontent.com/bobbyiliev/cloudflare-ddos-protection/main/protection.sh +``` + +Abra el script con su editor de texto favorito: + +```golpecito +nanoprotección.sh +``` + +Y actualice los siguientes detalles con sus datos de Cloudflare: + +```golpecito +CF_CONE_ID=TU_CF_ZONE_ID +CF_EMAIL_ADDRESS=TU_CF_EMAIL_ADDRESS +CF_API_KEY=TU_CF_API_KEY +``` + +Después de eso, haga que el script sea ejecutable: + +```golpecito +chmod +x ~/protección.sh +``` + +Finalmente, configure 2 trabajos Cron para que se ejecuten cada 30 segundos. Para editar su crontab ejecute: + +```golpecito +crontab-e +``` + +Y agregue el siguiente contenido: + +```golpecito +* * * * * /ruta-al-script/cloudflare/protection.sh +* * * * * (dormir 30; /ruta-al-script/cloudflare/protection.sh) +``` + +Tenga en cuenta que debe cambiar la ruta al script con la ruta real donde almacenó el script. + +## Conclusión + +Esta es una solución bastante sencilla y económica, una de las desventajas del script es que si su servidor no responde debido a un ataque, es posible que el script no se active en absoluto. + +Por supuesto, un mejor enfoque sería utilizar un sistema de monitoreo como Nagios y, basándose en las estadísticas del sistema de monitoreo, puede activar el script, ¡pero este desafío de script podría ser una buena experiencia de aprendizaje! + +Aquí hay otro gran recurso sobre cómo usar la API de Discord y enviar notificaciones a su canal de Discord con un script Bash: + +[Cómo utilizar Discord Webhooks para recibir notificaciones sobre el estado de su sitio web en Ubuntu 18.04](https://www.digitalocean.com/community/tutorials/how-to-use-discord-webhooks-to-get-notifications-for- el-estado-de-su-sitio-web-en-ubuntu-18-04) + +>{aviso} Este contenido se publicó inicialmente en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-automatically-enable-cloudflare-ddos-protection) \ No newline at end of file diff --git a/ebook/sp/assets/content/020-nginx-and-apache-log-parser.md b/ebook/sp/assets/content/020-nginx-and-apache-log-parser.md new file mode 100644 index 0000000..22bf286 --- /dev/null +++ b/ebook/sp/assets/content/020-nginx-and-apache-log-parser.md @@ -0,0 +1,83 @@ +# Analizador de scripts BASH para resumir sus registros de acceso a NGINX y Apache + +Una de las primeras cosas que normalmente haría en caso de que note un alto uso de CPU en algunos de mis servidores Linux sería verificar la lista de procesos con top o htop y en caso de que note muchos procesos de Apache o Nginx, Verificaría rápidamente mis registros de acceso para determinar qué ha causado o está causando el pico de CPU en mi servidor o para descubrir si está sucediendo algo malicioso. + +A veces, leer los registros puede resultar bastante intimidante, ya que el registro puede ser enorme y revisarlo manualmente puede llevar mucho tiempo. Además, el formato de registro sin formato puede resultar confuso para las personas con menos experiencia. + +Al igual que el capítulo anterior, ¡este capítulo será un desafío! Debe escribir un breve script bash que resumiría todo el registro de acceso sin la necesidad de instalar ningún software adicional. + +# Requisitos del guión + +Este script BASH necesita analizar y resumir sus registros de acceso y brindarle información muy útil como: + +* Las 20 páginas principales con más solicitudes POST +* Las 20 páginas principales con más solicitudes GET +* Las 20 principales direcciones IP y su ubicación geográfica + +## Guión de ejemplo + +Ya he preparado un script de demostración que podrías utilizar como referencia. ¡Pero te animo a que primero intentes escribir el guión tú mismo y solo después le eches un vistazo al mío! + +Para descargar el script, puede clonar el repositorio con el siguiente comando: + +```golpecito +clon de git https://github.com/bobbyiliev/quick_access_logs_summary.git +``` + +O ejecute el siguiente comando que descargará el script en su directorio actual: + +```golpecito +wget https://raw.githubusercontent.com/bobbyiliev/quick_access_logs_summary/master/spike_check +``` + +El script no realiza ningún cambio en su sistema, solo lee el contenido de su registro de acceso y lo resume; sin embargo, una vez que haya descargado el archivo, asegúrese de revisar el contenido usted mismo. + +## Ejecutando el script + +Todo lo que tienes que hacer una vez descargado el script es hacerlo ejecutable y ejecutarlo. + +Para hacerlo, ejecute el siguiente comando para que el script sea ejecutable: + +```golpecito +chmod +x pico_check +``` + +Luego ejecute el script: + +```golpecito +./spike_check /ruta/a/su/registro de acceso +``` + +Asegúrese de cambiar la ruta al archivo con la ruta real a su registro de acceso. Por ejemplo, si está utilizando Apache en un servidor Ubuntu, el comando exacto se vería así: + +```golpecito +./spike_check /var/log/apache2/access.log +``` + +Si está utilizando Nginx, el comando exacto sería casi el mismo, pero con la ruta al registro de acceso de Nginx: + +```golpecito +./spike_check /var/log/nginx/access.log +``` + +## Comprender el resultado + +Una vez que ejecute el script, puede tardar un poco dependiendo del tamaño del registro. + +El resultado que verías debería verse así: + +![Registro de acceso resumido](https://imgur.com/WWHVMrj.png) + +Básicamente, lo que podemos decir en este caso es que hemos recibido 16 solicitudes POST a nuestro archivo xmlrpc.php, que los atacantes suelen utilizar para intentar explotar sitios web de WordPress mediante el uso de varias combinaciones de nombre de usuario y contraseña. + +En este caso específico, no fue un gran ataque de fuerza bruta, pero nos da una indicación temprana y podemos tomar medidas para evitar un ataque mayor en el futuro. + +También podemos ver que había un par de direcciones IP rusas accediendo a nuestro sitio, por lo que en caso de que no espere ningún tráfico de Rusia, es posible que desee bloquear esas direcciones IP también. + +## Conclusión + +Este es un ejemplo de un script BASH simple que le permite resumir rápidamente sus registros de acceso y determinar si está sucediendo algo malicioso. + +Por supuesto, es posible que también quieras revisar manualmente los registros, ¡pero es un buen desafío intentar automatizar esto con Bash! + +>{aviso} Este contenido se publicó inicialmente en [DevDojo](https://devdojo.com/bobbyiliev/bash-script-to-summarize-your-nginx-and-apache-access-logs) \ No newline at end of file diff --git a/ebook/sp/assets/content/021-how-to-send-emails-with-bash.md b/ebook/sp/assets/content/021-how-to-send-emails-with-bash.md new file mode 100644 index 0000000..e808661 --- /dev/null +++ b/ebook/sp/assets/content/021-how-to-send-emails-with-bash.md @@ -0,0 +1,95 @@ +# Envío de correos electrónicos con Bash y SSMTP + +SSMTP es una herramienta que entrega correos electrónicos desde una computadora o un servidor a un host de correo configurado. + +SSMTP no es un servidor de correo electrónico en sí y no recibe correos electrónicos ni administra una cola. + +Uno de sus usos principales es reenviar correo electrónico automatizado (como alertas del sistema) desde su máquina a una dirección de correo electrónico externa. + +## Requisitos previos + +Necesitará lo siguiente para poder completar este tutorial con éxito: + +* Acceso a un servidor Ubuntu 18.04 como usuario no root con privilegios sudo y un firewall activo instalado en su servidor. Para configurarlos, consulte nuestra [Guía de configuración inicial del servidor para Ubuntu 18.04] (https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Un servidor SMTP junto con un nombre de usuario y contraseña SMTP, esto también funcionaría con el servidor SMTP de Gmail, o puedes configurar tu propio servidor SMTP siguiendo los pasos de este tutorial sobre [Cómo instalar y configurar Postfix como SMTP de solo envío Servidor en Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16- 04) + +## Instalación de SSMTP + +Para instalar SSMTP, primero deberá actualizar su caché apt con: + +```golpecito +actualización sudo apta +``` + +Luego ejecute el siguiente comando para instalar SSMTP: + +```golpecito +sudo apto instalar ssmtp +``` + +Otra cosa que necesitarías instalar es `mailutils`, para ello ejecuta el siguiente comando: + +```golpecito +sudo apto instalar mailutils +``` + +## Configurando SSMTP + +Ahora que tiene instalado `ssmtp`, para configurarlo para usar su servidor SMTP al enviar correos electrónicos, necesita editar el archivo de configuración SSMTP. + +Usando su editor de texto favorito, abra el archivo `/etc/ssmtp/ssmtp.conf`: + +```golpecito +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Debe incluir su configuración SMTP: + +``` +raíz = administrador de correo +mailhub=<^>tu_smtp_host.com<^>:587 +nombre de host=<^>tu_nombre de host<^> +AuthUser=<^>tu_nombre_de_usuario_de_gmail@tu_smtp_host.com<^> +AuthPass=<^>tu_contraseña_de_gmail<^> +FromLineOverride=SÍ +UtiliceSTARTTLS=YES +``` + +Guarda el archivo y cierra. + +## Envío de correos electrónicos con SSMTP + +Una vez realizada la configuración, para enviar un correo electrónico simplemente ejecute el siguiente comando: + +```golpecito +echo "<^>Aquí agregue el cuerpo de su correo electrónico<^>" | mail -s "<^>Aquí especifique el asunto de su correo electrónico<^>" <^>your_recepient_email@yourdomain.com<^> +``` + +Puede ejecutar esto directamente en su terminal o incluirlo en sus scripts bash. + +## Envío de un archivo con SSMTP (opcional) + +Si necesita enviar archivos como archivos adjuntos, puede utilizar `mpack`. + +Para instalar `mpack` ejecute el siguiente comando: + +```golpecito +sudo apto instalar mpack +``` + +A continuación, para enviar un correo electrónico con un archivo adjunto, ejecute el siguiente comando. + +```golpecito +mpack -s "<^>Su asunto aquí<^>" your_file.zip <^>your_recepient_email@yourdomain.com<^> +``` + +El comando anterior enviaría un correo electrónico a `<^>your_recepient_email@yourdomain.com<^>` con el `<^>your_file.zip<^>` adjunto. + +## Conclusión + +SSMTP es una forma excelente y confiable de implementar la funcionalidad de correo electrónico SMTP directamente en scripts bash. + +Para obtener más información sobre SSMTP, recomendaría consultar la documentación oficial [aquí](https://wiki.archlinux.org/index.php/SSMTP). + +>{aviso} Este contenido se publicó inicialmente en el [foro de la comunidad DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp ). \ No newline at end of file diff --git a/ebook/sp/assets/content/022-bash-password-generator.md b/ebook/sp/assets/content/022-bash-password-generator.md new file mode 100644 index 0000000..e808661 --- /dev/null +++ b/ebook/sp/assets/content/022-bash-password-generator.md @@ -0,0 +1,95 @@ +# Envío de correos electrónicos con Bash y SSMTP + +SSMTP es una herramienta que entrega correos electrónicos desde una computadora o un servidor a un host de correo configurado. + +SSMTP no es un servidor de correo electrónico en sí y no recibe correos electrónicos ni administra una cola. + +Uno de sus usos principales es reenviar correo electrónico automatizado (como alertas del sistema) desde su máquina a una dirección de correo electrónico externa. + +## Requisitos previos + +Necesitará lo siguiente para poder completar este tutorial con éxito: + +* Acceso a un servidor Ubuntu 18.04 como usuario no root con privilegios sudo y un firewall activo instalado en su servidor. Para configurarlos, consulte nuestra [Guía de configuración inicial del servidor para Ubuntu 18.04] (https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Un servidor SMTP junto con un nombre de usuario y contraseña SMTP, esto también funcionaría con el servidor SMTP de Gmail, o puedes configurar tu propio servidor SMTP siguiendo los pasos de este tutorial sobre [Cómo instalar y configurar Postfix como SMTP de solo envío Servidor en Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16- 04) + +## Instalación de SSMTP + +Para instalar SSMTP, primero deberá actualizar su caché apt con: + +```golpecito +actualización sudo apta +``` + +Luego ejecute el siguiente comando para instalar SSMTP: + +```golpecito +sudo apto instalar ssmtp +``` + +Otra cosa que necesitarías instalar es `mailutils`, para ello ejecuta el siguiente comando: + +```golpecito +sudo apto instalar mailutils +``` + +## Configurando SSMTP + +Ahora que tiene instalado `ssmtp`, para configurarlo para usar su servidor SMTP al enviar correos electrónicos, necesita editar el archivo de configuración SSMTP. + +Usando su editor de texto favorito, abra el archivo `/etc/ssmtp/ssmtp.conf`: + +```golpecito +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Debe incluir su configuración SMTP: + +``` +raíz = administrador de correo +mailhub=<^>tu_smtp_host.com<^>:587 +nombre de host=<^>tu_nombre de host<^> +AuthUser=<^>tu_nombre_de_usuario_de_gmail@tu_smtp_host.com<^> +AuthPass=<^>tu_contraseña_de_gmail<^> +FromLineOverride=SÍ +UtiliceSTARTTLS=YES +``` + +Guarda el archivo y cierra. + +## Envío de correos electrónicos con SSMTP + +Una vez realizada la configuración, para enviar un correo electrónico simplemente ejecute el siguiente comando: + +```golpecito +echo "<^>Aquí agregue el cuerpo de su correo electrónico<^>" | mail -s "<^>Aquí especifique el asunto de su correo electrónico<^>" <^>your_recepient_email@yourdomain.com<^> +``` + +Puede ejecutar esto directamente en su terminal o incluirlo en sus scripts bash. + +## Envío de un archivo con SSMTP (opcional) + +Si necesita enviar archivos como archivos adjuntos, puede utilizar `mpack`. + +Para instalar `mpack` ejecute el siguiente comando: + +```golpecito +sudo apto instalar mpack +``` + +A continuación, para enviar un correo electrónico con un archivo adjunto, ejecute el siguiente comando. + +```golpecito +mpack -s "<^>Su asunto aquí<^>" your_file.zip <^>your_recepient_email@yourdomain.com<^> +``` + +El comando anterior enviaría un correo electrónico a `<^>your_recepient_email@yourdomain.com<^>` con el `<^>your_file.zip<^>` adjunto. + +## Conclusión + +SSMTP es una forma excelente y confiable de implementar la funcionalidad de correo electrónico SMTP directamente en scripts bash. + +Para obtener más información sobre SSMTP, recomendaría consultar la documentación oficial [aquí](https://wiki.archlinux.org/index.php/SSMTP). + +>{aviso} Este contenido se publicó inicialmente en el [foro de la comunidad DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp ). \ No newline at end of file diff --git a/ebook/sp/assets/content/023-bash-redirection.md b/ebook/sp/assets/content/023-bash-redirection.md new file mode 100644 index 0000000..e808661 --- /dev/null +++ b/ebook/sp/assets/content/023-bash-redirection.md @@ -0,0 +1,95 @@ +# Envío de correos electrónicos con Bash y SSMTP + +SSMTP es una herramienta que entrega correos electrónicos desde una computadora o un servidor a un host de correo configurado. + +SSMTP no es un servidor de correo electrónico en sí y no recibe correos electrónicos ni administra una cola. + +Uno de sus usos principales es reenviar correo electrónico automatizado (como alertas del sistema) desde su máquina a una dirección de correo electrónico externa. + +## Requisitos previos + +Necesitará lo siguiente para poder completar este tutorial con éxito: + +* Acceso a un servidor Ubuntu 18.04 como usuario no root con privilegios sudo y un firewall activo instalado en su servidor. Para configurarlos, consulte nuestra [Guía de configuración inicial del servidor para Ubuntu 18.04] (https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Un servidor SMTP junto con un nombre de usuario y contraseña SMTP, esto también funcionaría con el servidor SMTP de Gmail, o puedes configurar tu propio servidor SMTP siguiendo los pasos de este tutorial sobre [Cómo instalar y configurar Postfix como SMTP de solo envío Servidor en Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16- 04) + +## Instalación de SSMTP + +Para instalar SSMTP, primero deberá actualizar su caché apt con: + +```golpecito +actualización sudo apta +``` + +Luego ejecute el siguiente comando para instalar SSMTP: + +```golpecito +sudo apto instalar ssmtp +``` + +Otra cosa que necesitarías instalar es `mailutils`, para ello ejecuta el siguiente comando: + +```golpecito +sudo apto instalar mailutils +``` + +## Configurando SSMTP + +Ahora que tiene instalado `ssmtp`, para configurarlo para usar su servidor SMTP al enviar correos electrónicos, necesita editar el archivo de configuración SSMTP. + +Usando su editor de texto favorito, abra el archivo `/etc/ssmtp/ssmtp.conf`: + +```golpecito +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Debe incluir su configuración SMTP: + +``` +raíz = administrador de correo +mailhub=<^>tu_smtp_host.com<^>:587 +nombre de host=<^>tu_nombre de host<^> +AuthUser=<^>tu_nombre_de_usuario_de_gmail@tu_smtp_host.com<^> +AuthPass=<^>tu_contraseña_de_gmail<^> +FromLineOverride=SÍ +UtiliceSTARTTLS=YES +``` + +Guarda el archivo y cierra. + +## Envío de correos electrónicos con SSMTP + +Una vez realizada la configuración, para enviar un correo electrónico simplemente ejecute el siguiente comando: + +```golpecito +echo "<^>Aquí agregue el cuerpo de su correo electrónico<^>" | mail -s "<^>Aquí especifique el asunto de su correo electrónico<^>" <^>your_recepient_email@yourdomain.com<^> +``` + +Puede ejecutar esto directamente en su terminal o incluirlo en sus scripts bash. + +## Envío de un archivo con SSMTP (opcional) + +Si necesita enviar archivos como archivos adjuntos, puede utilizar `mpack`. + +Para instalar `mpack` ejecute el siguiente comando: + +```golpecito +sudo apto instalar mpack +``` + +A continuación, para enviar un correo electrónico con un archivo adjunto, ejecute el siguiente comando. + +```golpecito +mpack -s "<^>Su asunto aquí<^>" your_file.zip <^>your_recepient_email@yourdomain.com<^> +``` + +El comando anterior enviaría un correo electrónico a `<^>your_recepient_email@yourdomain.com<^>` con el `<^>your_file.zip<^>` adjunto. + +## Conclusión + +SSMTP es una forma excelente y confiable de implementar la funcionalidad de correo electrónico SMTP directamente en scripts bash. + +Para obtener más información sobre SSMTP, recomendaría consultar la documentación oficial [aquí](https://wiki.archlinux.org/index.php/SSMTP). + +>{aviso} Este contenido se publicó inicialmente en el [foro de la comunidad DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp ). \ No newline at end of file diff --git a/ebook/sp/assets/content/024-automating-wordpress-lamp-with-bash.md b/ebook/sp/assets/content/024-automating-wordpress-lamp-with-bash.md new file mode 100644 index 0000000..e808661 --- /dev/null +++ b/ebook/sp/assets/content/024-automating-wordpress-lamp-with-bash.md @@ -0,0 +1,95 @@ +# Envío de correos electrónicos con Bash y SSMTP + +SSMTP es una herramienta que entrega correos electrónicos desde una computadora o un servidor a un host de correo configurado. + +SSMTP no es un servidor de correo electrónico en sí y no recibe correos electrónicos ni administra una cola. + +Uno de sus usos principales es reenviar correo electrónico automatizado (como alertas del sistema) desde su máquina a una dirección de correo electrónico externa. + +## Requisitos previos + +Necesitará lo siguiente para poder completar este tutorial con éxito: + +* Acceso a un servidor Ubuntu 18.04 como usuario no root con privilegios sudo y un firewall activo instalado en su servidor. Para configurarlos, consulte nuestra [Guía de configuración inicial del servidor para Ubuntu 18.04] (https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-18-04) + +* Un servidor SMTP junto con un nombre de usuario y contraseña SMTP, esto también funcionaría con el servidor SMTP de Gmail, o puedes configurar tu propio servidor SMTP siguiendo los pasos de este tutorial sobre [Cómo instalar y configurar Postfix como SMTP de solo envío Servidor en Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-postfix-as-a-send-only-smtp-server-on-ubuntu-16- 04) + +## Instalación de SSMTP + +Para instalar SSMTP, primero deberá actualizar su caché apt con: + +```golpecito +actualización sudo apta +``` + +Luego ejecute el siguiente comando para instalar SSMTP: + +```golpecito +sudo apto instalar ssmtp +``` + +Otra cosa que necesitarías instalar es `mailutils`, para ello ejecuta el siguiente comando: + +```golpecito +sudo apto instalar mailutils +``` + +## Configurando SSMTP + +Ahora que tiene instalado `ssmtp`, para configurarlo para usar su servidor SMTP al enviar correos electrónicos, necesita editar el archivo de configuración SSMTP. + +Usando su editor de texto favorito, abra el archivo `/etc/ssmtp/ssmtp.conf`: + +```golpecito +sudo nano /etc/ssmtp/ssmtp.conf +``` + +Debe incluir su configuración SMTP: + +``` +raíz = administrador de correo +mailhub=<^>tu_smtp_host.com<^>:587 +nombre de host=<^>tu_nombre de host<^> +AuthUser=<^>tu_nombre_de_usuario_de_gmail@tu_smtp_host.com<^> +AuthPass=<^>tu_contraseña_de_gmail<^> +FromLineOverride=SÍ +UtiliceSTARTTLS=YES +``` + +Guarda el archivo y cierra. + +## Envío de correos electrónicos con SSMTP + +Una vez realizada la configuración, para enviar un correo electrónico simplemente ejecute el siguiente comando: + +```golpecito +echo "<^>Aquí agregue el cuerpo de su correo electrónico<^>" | mail -s "<^>Aquí especifique el asunto de su correo electrónico<^>" <^>your_recepient_email@yourdomain.com<^> +``` + +Puede ejecutar esto directamente en su terminal o incluirlo en sus scripts bash. + +## Envío de un archivo con SSMTP (opcional) + +Si necesita enviar archivos como archivos adjuntos, puede utilizar `mpack`. + +Para instalar `mpack` ejecute el siguiente comando: + +```golpecito +sudo apto instalar mpack +``` + +A continuación, para enviar un correo electrónico con un archivo adjunto, ejecute el siguiente comando. + +```golpecito +mpack -s "<^>Su asunto aquí<^>" your_file.zip <^>your_recepient_email@yourdomain.com<^> +``` + +El comando anterior enviaría un correo electrónico a `<^>your_recepient_email@yourdomain.com<^>` con el `<^>your_file.zip<^>` adjunto. + +## Conclusión + +SSMTP es una forma excelente y confiable de implementar la funcionalidad de correo electrónico SMTP directamente en scripts bash. + +Para obtener más información sobre SSMTP, recomendaría consultar la documentación oficial [aquí](https://wiki.archlinux.org/index.php/SSMTP). + +>{aviso} Este contenido se publicó inicialmente en el [foro de la comunidad DigitalOcean](https://www.digitalocean.com/community/questions/how-to-send-emails-from-a-bash-script-using-ssmtp ). \ No newline at end of file diff --git a/ebook/sp/assets/content/100-bash-wrap-up.md b/ebook/sp/assets/content/100-bash-wrap-up.md new file mode 100644 index 0000000..81a81a5 --- /dev/null +++ b/ebook/sp/assets/content/100-bash-wrap-up.md @@ -0,0 +1,15 @@ +# Envolver + +¡Felicidades! ¡Acabas de completar la guía básica de Bash! + +Si esto le resultó útil, asegúrese de destacar el proyecto en [GitHub](https://github.com/bobbyiliev/introduction-to-bash-scripting). + +Si tiene alguna sugerencia para mejorar, asegúrese de contribuir con solicitudes de extracción o problemas abiertos. + +En esta introducción al libro de secuencias de comandos Bash, solo cubrimos los conceptos básicos, ¡pero aún tienes suficiente en tu haber para comenzar a escribir algunas secuencias de comandos increíbles y automatizar tareas diarias! + +¡Como siguiente paso, intenta escribir tu propio guión y compártelo con el mundo! ¡Esta es la mejor manera de aprender cualquier lenguaje de programación o scripting nuevo! + +En caso de que este libro te haya inspirado a escribir algunos scripts Bash interesantes, asegúrate de twittear sobre ello y etiquetar a [@bobbyiliev_](https://twitter.com) para que podamos verlo. + +¡Felicitaciones nuevamente por completar este libro! \ No newline at end of file diff --git a/ebook/sp/assets/cover.jpg b/ebook/sp/assets/cover.jpg new file mode 100644 index 0000000..d6db238 Binary files /dev/null and b/ebook/sp/assets/cover.jpg differ diff --git a/ebook/sp/assets/cover.jpg-bak b/ebook/sp/assets/cover.jpg-bak new file mode 100644 index 0000000..f428793 Binary files /dev/null and b/ebook/sp/assets/cover.jpg-bak differ diff --git a/ebook/sp/assets/ibis.php b/ebook/sp/assets/ibis.php new file mode 100644 index 0000000..59f7c15 --- /dev/null +++ b/ebook/sp/assets/ibis.php @@ -0,0 +1,34 @@ + 'Introduction au script Bash', + + /** + * The author name. + */ + 'author' => 'Bobby Iliev', + + /** + * The list of fonts to be used in the different themes. + */ + 'fonts' => [ + // 'calibri' => 'Calibri-Regular.ttf', + // 'times' => 'times-regular.ttf', + ], + + /** + * Page ranges to be used with the sample command. + */ + 'sample' => [ + [1, 35] + ], + + /** + * A notice printed at the final page of a generated sample. + */ + 'sample_notice' => 'Extrait de "Introduction au script Bash" par Bobby Iliev.
+ Pour davantage d\'informations, Cliquez ici.', +]; diff --git a/ebook/sp/assets/theme-dark.html b/ebook/sp/assets/theme-dark.html new file mode 100644 index 0000000..6f12e6d --- /dev/null +++ b/ebook/sp/assets/theme-dark.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/ebook/sp/assets/theme-light.html b/ebook/sp/assets/theme-light.html new file mode 100644 index 0000000..561b80c --- /dev/null +++ b/ebook/sp/assets/theme-light.html @@ -0,0 +1,171 @@ +
+ + + +
+ + diff --git a/index.html b/index.html index b484d0a..9ba9ef1 100644 --- a/index.html +++ b/index.html @@ -18,33 +18,8 @@ - - -
@@ -63,8 +38,6 @@ class="mr-0 font-bold duration-100 md:mr-3 lg:mr-8 transition-color hover:text-indigo-600">Sponsors Chapters - Interactive Training Blog - +
@@ -361,7 +354,7 @@
Dark Theme

Download the Dark theme of the Introduction to Bash Scripting eBook

- Free Download + Free Download
@@ -381,7 +374,7 @@
Light Theme

Download the Light theme of the Introduction to Bash Scripting eBook

- Free Download + Free Download @@ -390,53 +383,27 @@
Light Theme
- -
-
-

- Introduction to Bash with Interactive training -

-

- Powered by - Katacoda

-
-
- - Start Free Training - -
-
-
- -
-
-
-
Free Download - +

Enjoying the free eBook?

Support this opensource project by staring it on GitHub!

- + - + Star the project - +
@@ -458,11 +425,6 @@

Enjoying the free eBook?

-
- - Interactive Training - -
Blog @@ -504,23 +466,12 @@

Enjoying the free eBook?

- © 2020 Designed with Tails + © 2022-2020 Designed with Tails

- - + + + diff --git a/index.js b/index.js new file mode 100644 index 0000000..563d1a4 --- /dev/null +++ b/index.js @@ -0,0 +1,32 @@ +// a little JS for the mobile nav button + +var year = new Date().getFullYear(); +console.log(year); +document.getElementById("year").innerHTML = year; + +if (document.getElementById('nav-mobile-btn')) { + document.getElementById('nav-mobile-btn').addEventListener('click', function () { + if (this.classList.contains('close')) { + document.getElementById('nav').classList.add('hidden'); + this.classList.remove('close'); + } else { + document.getElementById('nav').classList.remove('hidden'); + this.classList.add('close'); + } + }); +} +// ###################################### + +// a little JS for the mobile nav button + +if (document.getElementById('nav-mobile-btn')) { + document.getElementById('nav-mobile-btn').addEventListener('click', function () { + if (this.classList.contains('close')) { + document.getElementById('nav').classList.add('hidden'); + this.classList.remove('close'); + } else { + document.getElementById('nav').classList.remove('hidden'); + this.classList.add('close'); + } + }); +} \ No newline at end of file diff --git a/style.css b/style.css new file mode 100644 index 0000000..6b6bd95 --- /dev/null +++ b/style.css @@ -0,0 +1,27 @@ + /* Small CSS to Hide elements at 1520px size */ + +html { + scroll-behavior: smooth; +} + +@media(max-width:1520px) { + .left-svg { + display: none; + } +} + +/* small css for the mobile nav close */ +#nav-mobile-btn.close span:first-child { + transform: rotate(45deg); + top: 4px; + position: relative; + background: #a0aec0; +} + +#nav-mobile-btn.close span:nth-child(2) { + transform: rotate(-45deg); + margin-top: 0px; + background: #a0aec0; +} + +/* Css is same for both the html file index.html and training.html */ \ No newline at end of file diff --git a/training.html b/training.html deleted file mode 100644 index 8d6e92e..0000000 --- a/training.html +++ /dev/null @@ -1,204 +0,0 @@ - - - - - - Bobby Iliev - Introduction to Bash Scripting - - - - - - - - - - - - - - - - - - - - - -
-
- - - Bobby Iliev. - - - - - - - - -
-
- -
-
- - -
-
-
- Free Download - -
-

Download the eBook for free!

-

Are you ready to learn Bash and start writing awesome Bash scripts?

-
- Free Download - -
-
-
- - - - - \ No newline at end of file