Execução de Scripts no Linux

Introdução

Este laboratório foca na compreensão e no uso do comando source no Linux, uma ferramenta poderosa para executar scripts diretamente no shell atual. Ao contrário da execução convencional de scripts, que ocorre em um subprocesso separado, o comando source executa os comandos de um arquivo dentro do ambiente do shell atual. Isso permite que variáveis e funções definidas no script persistam na sua sessão ativa.

Ao longo deste laboratório, você aprenderá:

Como criar e executar scripts usando o comando source
Como passar parâmetros para scripts ao usar o source
Como o comando source difere da execução comum de scripts
Como utilizar o comando source para configurar variáveis de ambiente

Ao final deste laboratório, você estará familiarizado com o uso do comando source para um shell scripting eficiente e para o gerenciamento de ambientes no Linux.

Criando e Executando um Script Básico com Source

Nesta etapa, criaremos um arquivo de script simples e usaremos o comando source para executá-lo em nosso ambiente de shell atual. Isso nos ajudará a entender como o source difere da execução normal de scripts.

Quando você executa um script normalmente (usando ./script.sh), o shell cria um novo subprocesso para processá-lo. Quaisquer variáveis ou funções definidas nesse script existem apenas dentro desse subprocesso e desaparecem quando o script termina. No entanto, ao usar o comando source (ou seu atalho .), os comandos do script são executados no seu ambiente de shell atual, permitindo que variáveis e funções persistam após a conclusão do script.

Vamos criar um script básico para demonstrar esse conceito:

1. Navegue até o diretório do projeto

Primeiro, certifique-se de estar no diretório correto:

cd ~/project

2. Crie um arquivo de script simples

Crie um novo arquivo chamado variables.sh usando o editor nano:

nano variables.sh

Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash
## This script sets an environment variable
export WEATHER="Sunny"
echo "The weather is now set to: $WEATHER"

Pressione Ctrl+O para salvar o arquivo, depois Enter para confirmar o nome do arquivo e, finalmente, Ctrl+X para sair do nano.

3. Torne o script executável

Antes de podermos executar o script, precisamos torná-lo executável:

chmod +x variables.sh

4. Execute o script normalmente

Primeiro, vamos executar o script da maneira tradicional:

./variables.sh

Você deverá ver uma saída semelhante a:

The weather is now set to: Sunny

Agora, verifique se a variável WEATHER existe no seu shell atual:

echo $WEATHER

Provavelmente você não verá nada ou verá uma linha vazia. Isso ocorre porque a variável foi definida apenas no subprocesso que executou o script, e não no seu shell atual.

5. Execute o script com source

Agora, vamos usar o comando source para executar o script:

source variables.sh

Você verá a mesma saída:

The weather is now set to: Sunny

Verifique a variável WEATHER novamente:

echo $WEATHER

Desta vez, você deverá ver:

Sunny

A variável WEATHER agora existe no seu shell atual porque você usou o comando source para executar o script.

6. Usando a notação de atalho

Você também pode usar o ponto (.) como atalho para o comando source:

. ./variables.sh

Isso produzirá o mesmo resultado que usar source variables.sh. O prefixo ./ indica ao shell para buscar o script no diretório atual.

Usando Source com Parâmetros

Nesta etapa, aprenderemos como passar parâmetros para um script ao usar o comando source. Isso é útil quando você precisa tornar seus scripts mais flexíveis e reutilizáveis.

Assim como na execução normal de scripts, você pode passar argumentos para um script ao usar o comando source. Dentro do script, esses argumentos são acessíveis através dos parâmetros posicionais padrão ($1, $2, etc.), exatamente como seriam ao executar o script diretamente.

1. Criando um script que aceita parâmetros

Crie um novo arquivo chamado greeting.sh no diretório ~/project:

cd ~/project
nano greeting.sh

Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash
## This script accepts a name parameter and sets a greeting variable

## Check if a parameter was provided
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Set the greeting environment variable
export GREETING="Hello, $NAME!"
echo "$GREETING"

Salve e saia do nano pressionando Ctrl+O, Enter e depois Ctrl+X.

2. Torne o script executável

chmod +x greeting.sh

3. Execute o script com source e um parâmetro

Vamos executar o script com source e passar um parâmetro de nome:

source greeting.sh "Alice"

Você deverá ver a saída:

Hello, Alice!

Agora verifique se a variável GREETING está definida no seu shell atual:

echo $GREETING

Você deverá ver:

Hello, Alice!

4. Execute com um parâmetro diferente

Tente executar o script com source novamente usando um nome diferente:

source greeting.sh "Bob"

Saída:

Hello, Bob!

Verifique a variável GREETING novamente:

echo $GREETING

Saída:

Hello, Bob!

Observe como a variável GREETING foi atualizada com o novo valor.

5. Execute com source sem parâmetros

Você também pode executar o script com source sem nenhum parâmetro:

source greeting.sh

Saída:

Hello, Guest!

O script usa um valor padrão ("Guest") quando nenhum parâmetro é fornecido.

Verifique a variável GREETING mais uma vez:

echo $GREETING

Saída:

Hello, Guest!

Isso demonstra como você pode tornar seus scripts adaptáveis processando diferentes parâmetros de entrada.

Criando um Script de Ambiente de Desenvolvimento

Nesta etapa, criaremos um exemplo mais prático: um script que configura um ambiente de desenvolvimento com múltiplas variáveis. Este é um caso de uso comum para o comando source em cenários reais.

1. Criando o script de ambiente de desenvolvimento

Crie um novo arquivo chamado dev_env.sh no diretório ~/project:

cd ~/project
nano dev_env.sh

Adicione o seguinte conteúdo ao arquivo:

#!/bin/bash
## Development environment setup script

## Database connection settings
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## API settings
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Application paths
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Create directories if they don't exist
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Display confirmation message
echo "Development environment configured with the following settings:"
echo "-----------------------------------------------------------"
echo "Database: $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "API URL: $API_URL"
echo "App Root: $APP_ROOT"
echo "Log Directory: $LOG_DIR"
echo "-----------------------------------------------------------"
echo "Environment is ready for development!"

Salve e saia do nano pressionando Ctrl+O, Enter e depois Ctrl+X.

2. Torne o script executável

chmod +x dev_env.sh

3. Execute o script de ambiente de desenvolvimento com source

Agora, vamos usar o source para executar o script e configurar nosso ambiente de desenvolvimento:

source dev_env.sh

Você deverá ver uma saída semelhante a:

Development environment configured with the following settings:
-----------------------------------------------------------
Database: dev_user@localhost:5432/dev_database
API URL: http://localhost:3000/api
App Root: /home/labex/project/app
Log Directory: /home/labex/project/logs
-----------------------------------------------------------
Environment is ready for development!

4. Verifique se as variáveis de ambiente estão definidas

Vamos verificar algumas das variáveis de ambiente que foram definidas pelo script:

echo "Database connection string: $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Saída:

Database connection string: dev_user:dev_password@localhost:5432/dev_database

Verifique as configurações da API:

echo "API settings: $API_URL with key $API_KEY"

Saída:

API settings: http://localhost:3000/api with key dev_api_key_123

5. Verifique se os diretórios foram criados

Verifique se os diretórios especificados no script foram criados:

ls -la ~/project/app ~/project/logs

Você deverá ver uma saída confirmando que ambos os diretórios existem.

Este exemplo demonstra como você pode usar o comando source para configurar um ambiente de desenvolvimento completo com múltiplas variáveis de ambiente e configurações. Essa abordagem é comumente usada em fluxos de trabalho de desenvolvimento para alternar entre diferentes ambientes (desenvolvimento, teste, produção, etc.).

Resumo

Neste laboratório, você aprendeu como usar o comando source no Linux para executar scripts no ambiente de shell atual. Aqui está um resumo do que você realizou:

Criando e Executando Scripts Básicos com Source: Você aprendeu como o uso do source difere da execução normal de scripts, permitindo que variáveis e funções definidas no script persistam na sua sessão de shell atual.
Passando Parâmetros para Scripts com Source: Você explorou como tornar os scripts mais flexíveis passando parâmetros para eles ao usar o comando source e como processar esses parâmetros dentro do script.
Configurando Ambientes de Desenvolvimento: Você criou um script prático que configura um ambiente de desenvolvimento com múltiplas variáveis de ambiente e configurações, um caso de uso real e comum para o comando source.

O comando source é uma ferramenta poderosa no shell scripting do Linux que permite:

Definir variáveis de ambiente que persistem durante toda a sua sessão de shell
Definir funções que podem ser usadas posteriormente na sua sessão
Criar configurações modulares que podem ser reutilizadas
Configurar ambientes complexos de forma rápida e consistente

Essas habilidades são fundamentais para qualquer pessoa que trabalhe com sistemas Linux, particularmente para desenvolvedores, administradores de sistemas e engenheiros de DevOps. Ao dominar o comando source, você pode criar scripts mais eficientes e organizados para gerenciar seu ambiente Linux.