Pular para o conteúdo
Início » Tudo o que Você Precisa Saber sobre Shell Scripting em DevOps

Tudo o que Você Precisa Saber sobre Shell Scripting em DevOps

Shell script de maneira facil - nerd expert

O Shell Scripting é uma habilidade essencial em DevOps, permitindo a automação de tarefas repetitivas, gerenciamento de configurações do sistema e execução de comandos em sequência. Neste artigo, vamos cobrir os conceitos básicos e a sintaxe necessária para iniciar sua jornada de Shell Scripting no DevOps. A melhor parte? Você pode aprender facilmente, sem precisar praticar muito. Vamos lá!

O que é Shell Scripting?

O Shell Scripting é uma linguagem de script que é executada em um ambiente de shell e é usada para automatizar tarefas, gerenciar configurações do sistema e executar uma série de comandos por meio de scripts. Isso é particularmente útil em administração de sistemas, instalação de software, manipulação de arquivos e muito mais.

A Sintaxe Básica do Shell Script

Um script Shell tem uma sintaxe básica que começa com a linha especial conhecida como “shebang”. O shebang especifica o interpretador a ser usado para executar o script. Geralmente, usamos #!/bin/bash para indicar o uso do interpretador Bash.

#!/bin/bash

# Aqui vão variáveis, comandos, funções, etc.

Executando um Script Shell

Para executar um script Shell, siga estas etapas:

  1. Torne o script executável com o comando chmod u+x <scriptFile>.
  2. Execute o script usando ./<fileName> no terminal.

Lendo Entradas do Usuário

O comando read é usado para ler a entrada do usuário a partir do terminal. Você pode exibir uma mensagem de prompt e armazenar a entrada do usuário em uma variável.

#!/bin/bash

echo "Digite o nome de usuário: "
read username
echo $username

read -p "Digite o novo nome de usuário: " newusername
echo $newusername

read -sp "Digite a senha: " password
echo ""
echo $password

# Se você não quiser atribuir um nome de variável, pode usar $REPLY para obter o valor lido.

Substituição de Comandos

A substituição de comandos permite que a saída de um comando seja usada como valor de uma variável. Você pode fazer isso usando backticks (``) ou o símbolo$`.

#!/bin/bash

echo "Método 1 - usando backticks"
working_dir=`pwd`
echo $working_dir

echo "Método 2 - usando $"
working_dir=$(pwd)
echo $working_dir

Passagem de Argumentos

Você pode passar argumentos para um script Shell que podem ser acessados dentro do script usando as variáveis especiais $1, $2, $3, etc.

#!/bin/bash

echo "Nome do arquivo: "$0
echo "Primeiro Argumento: "$1
echo "Segundo Argumento: "$2
echo "Todos os Argumentos: "$@
echo "Número de Argumentos: "$#

Operações Aritméticas

Para realizar operações aritméticas em Shell Scripting, você precisa usar parênteses duplos (( )), que são usados para expansão aritmética em números inteiros.

#!/bin/bash

n1=10
n2=5

echo "Soma de dois números: "$(($n1+$n2))
echo "Subtração de dois números: "$(($n1-$n2))
echo "Multiplicação de dois números: "$(($n1*$n2))
echo "Divisão de dois números: "$(($n1/$n2))
echo "Módulo de dois números: "$(($n1%$n2))

Condicionais

No Shell Scripting, você pode usar [[ ]] ou o comando test para avaliar expressões condicionais. Aqui estão alguns operadores condicionais comuns:

  • -z STRING: String vazia
  • -n STRING: String não vazia
  • STRING1 == STRING2: Igual
  • STRING1 != STRING2: Diferente
  • NUM -eq NUM: Igual
  • NUM -ne NUM: Diferente
  • NUM -lt NUM: Menor que
  • NUM -le NUM: Menor ou igual a
  • NUM -gt NUM: Maior que
  • NUM -ge NUM: Maior ou igual a
  • ! EXPR: Não
  • X && Y: E
  • X || Y: Ou
#!/bin/bash

a=10
b=20

if [[ $a -lt $b ]]; then
   echo "a é menor que b"
else
   echo "a não é menor que b"
fi

if test "$a" -lt "$b"; then
   echo "a é menor que b"
else
   echo "a não é menor que b"
fi

Estruturas de Repetição

Em Shell Scripting, você pode usar várias estruturas de repetição, incluindo if-else, for, while e until.

if-else:

O if-else é uma declaração condicional que permite executar comandos diferentes com base em uma condição.

#!/bin/bash

if [[ -e ./ifelse.sh ]]; then
  echo "O arquivo existe"
else
  echo "O arquivo não existe"
fi

for:

O loop for é usado para iterar sobre uma sequência de valores.

#!/bin/bash

for i in {1..10}; do
  echo "Valor: $i"
done

# Estilo C/Loop Antigo do for
for((i=0; i<=10; i++)); do
  echo "Valor: $i"
done

while:

O loop while é usado para executar comandos repetidamente enquanto uma condição for verdadeira.

#!/bin/bash

count=0

while [ $count -lt 5 ]; do
  echo $count
  count=$(($count+1))
done

until:

O loop until é usado para executar um bloco de código repetidamente até que uma determinada condição seja atendida.

#!/bin/bash

count=1

until [ $count -gt 5 ]; do
    echo $count
    count=$(($count+1))
done

Arrays

Um array é uma variável que pode armazenar múltiplos valores sob um único nome. Você pode acessar os valores do array usando ${arrayVarName[@]} ou ${arrayVarName[0]} para acessar o primeiro elemento, ${arrayVarName[-1]} para o último elemento e

${#arrayVarName[@]} para a quantidade de elementos.

#!/bin/bash

# Declarando um array de frutas
fruits=("maçã" "banana" "laranja" "goiaba")

# Imprimindo todo o array
echo "Todas as frutas (@): ${fruits[@]}"
echo "Todas as frutas (*): ${fruits[*]}"

# Imprimindo o terceiro elemento do array
echo "Terceira fruta: ${fruits[2]}"

# Imprimindo o tamanho do array
echo "Número de frutas: ${#fruits[@]}"

Break e Continue

break é usado para sair de um loop quando uma condição é atendida, enquanto continue é usado para pular a iteração atual e avançar para a próxima.

#!/bin/bash

count=1

while true; do
  echo "Contagem é $count"
  count=$(($count+1))
  if [ $count -gt 5 ]; then
    echo "Instrução break alcançada"
    break
  fi
done

for i in {1..10}; do
  if [ $i -eq 5 ]; then
    continue
  fi
  echo $i
done

Funções

Funções permitem que você agrupe comandos para realizar uma tarefa específica, promovendo a reutilização de código.

Função Normal:

#!/bin/bash

soma(){
        echo "Os números são: $n1 $n2"
        sum_val=$(($n1+$n2))
        echo "Soma: $sum_val"
}

n1=$1
n2=$2
soma

Função com Valores de Retorno:

#!/bin/bash

soma(){
        echo "Os números são: $n1 $n2"
        sum_val=$(($n1+$n2))
        echo "Soma: $sum_val"
        return $sum_val
}

n1=$1
n2=$2
soma

echo "Valor retornado pela função é $?"

Variáveis

Em Shell Scripting, você pode usar variáveis globais e locais. Variáveis globais são definidas fora de funções e podem ser acessadas em todo o script. Variáveis locais são definidas dentro de funções e só podem ser acessadas dentro delas.

#!/bin/bash

# x e y são variáveis globais
x=10
y=20

soma(){
        sum=$(($x+$y))
        echo "Adição de Variáveis Globais: $sum"
}

soma

sub(){
        # a e b são variáveis locais
        local a=20
        local b=10
        local sub=$(($a-$b))
        echo "Subtração de Variáveis Locais: $sub"
}

sub

Dicionários

Em Shell Scripting, dicionários são implementados usando arrays associativos, onde as chaves são strings em vez de números inteiros.

#!/bin/bash

# Declarando um array associativo
declare -A cores

# Adicionando pares chave-valor
cores['maçã']='vermelha'
cores['banana']='amarela'
cores['laranja']='laranja'
cores['goiaba']='verde'
cores['cereja']='vermelha'

echo "Tamanho do dicionário: ${#cores[@]}"
echo "Cor da maçã: ${cores['maçã']}"
echo "Todas as chaves do dicionário: ${!cores[@]}"
echo "Todos os valores do dicionário: ${cores[@]}"

# Excluindo a chave 'cereja'
unset cores['cereja']
echo "Novo dicionário: ${cores[@]}"

# Iterando sobre as chaves
for chave in ${!cores[@]}; do
        echo $chave
done

# Iterando sobre os valores
for valor in ${cores[@]}; do
        echo $valor
done

Opções do Conjunto – O Salvador

O comando set permite alterar ou exibir os valores das opções do shell. Você pode usá-lo para configurar opções, como depuração ou tratamento de erros.

  • set -x: Modo de depuração, exibe todos os comandos executados antes de sua saída.
  • set -e: Sai imediatamente do script quando um código de saída diferente de zero é encontrado. Isso é útil para garantir que seu script pare quando ocorrerem erros.
  • set -o pipefail: Garante que uma série de comandos em uma tubulação falhe se algum deles falhar. Isso é útil para detectar erros em comandos de tubulação.

Agora você tem uma compreensão sólida dos fundamentos do Shell Scripting em DevOps. Com esses conceitos e sintaxe básica, você está pronto para desenvolver scripts mais complexos e automatizar tarefas em sua jornada de DevOps. Espero que este artigo tenha ajudado você a compreender o conceito. Obrigado!