Execução de Scripts Linux

Introdução

Este laboratório foca-se na compreensão e utilização do comando source no Linux, uma ferramenta poderosa para executar scripts na shell atual. Ao contrário da execução normal de scripts, que é executada num subprocesso separado, o comando source executa comandos de um ficheiro no ambiente da shell atual. Isto permite que variáveis e funções definidas no script persistam na sua sessão atual.

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

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

Ao final deste laboratório, você estará confortável em usar o comando source para uma eficiente scripting de shell Linux e gerenciamento de ambiente.

Criando e Executando um Script Básico

Nesta etapa, criaremos um ficheiro de script simples e usaremos o comando source para executá-lo no 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), a shell cria um novo subprocesso para executar o script. Quaisquer variáveis ou funções definidas nesse script existem apenas dentro desse subprocesso e desaparecem quando o script termina. No entanto, quando você usa o comando source (ou sua abreviação .), os comandos no 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 este conceito:

1. Navegue para o diretório do projeto

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

cd ~/project

2. Crie um ficheiro de script simples

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

nano variables.sh

Adicione o seguinte conteúdo ao ficheiro:

#!/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 ficheiro, depois Enter para confirmar o nome do ficheiro 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ê deve ver uma saída semelhante a:

The weather is now set to: Sunny

Agora, verifique se a variável WEATHER existe na sua shell atual:

echo $WEATHER

Você provavelmente não verá nenhuma saída, ou uma linha vazia. Isso ocorre porque a variável foi definida apenas no subprocesso que executou o script, não na sua 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ê deve ver:

Sunny

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

6. Usando a notação abreviada

Você também pode usar a notação abreviada de ponto (.) para o comando source:

. variables.sh

Isso produzirá o mesmo resultado que usar source variables.sh.

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.), assim como seriam ao executar o script diretamente.

1. Criando um script que aceita parâmetros

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

cd ~/project
nano greeting.sh

Adicione o seguinte conteúdo ao ficheiro:

#!/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ê deve ver a saída:

Hello, Alice!

Agora, verifique se a variável GREETING está definida na sua shell atual:

echo $GREETING

Você deve ver:

Hello, Alice!

4. Execute com source e um parâmetro diferente

Tente executar o script com source novamente com 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 do mundo real.

1. Criando o script do ambiente de desenvolvimento

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

cd ~/project
nano dev_env.sh

Adicione o seguinte conteúdo ao ficheiro:

#!/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 do ambiente de desenvolvimento com source

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

source dev_env.sh

Você deve 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ê deve ver a saída mostrando 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 da shell atual. Aqui está um resumo do que você realizou:

1. Criando e Executando Scripts Básicos: Você aprendeu como o uso de source difere da execução regular de scripts, pois permite que variáveis e funções definidas no script persistam na sua sessão da shell atual.

2. Passando Parâmetros para Scripts Executados 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.

3. 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, que é um caso de uso comum no mundo real para o comando source.

O comando source é uma ferramenta poderosa em scripting Linux que permite:

• Definir variáveis de ambiente que persistem em sua sessão da shell
• Definir funções que podem ser usadas posteriormente em 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 DevOps. Ao dominar o comando source, você pode criar scripts mais eficientes e organizados para gerenciar seu ambiente Linux.