Scripts CGI no Linux: exemplos de configuração do Apache CGI-bin

A Common Gateway Interface (CGI) é uma tecnologia essencial que serve como um link entre clientes e servidores web, permitindo a execução de scripts e programas em um servidor web. Embora as tecnologias mais recentes tenham substituído amplamente o CGI, ele continua sendo uma ferramenta útil para administradores de sistema Linux para monitoramento rápido do sistema e tarefas administrativas por meio de navegadores da web.

Neste tutorial você aprenderá:

Como instalar o servidor web Apache no Ubuntu Linux
Como criar e executar scripts CGI em diversas linguagens de programação
Como acessar e testar scripts CGI em um navegador da web

FATO INTERESSANTE SOBRE CGI COM APACHE NO LINUX
O Apache no Linux tem sido historicamente uma das principais plataformas para CGI devido à sua robustez e flexibilidade. Apesar do surgimento de tecnologias mais recentes, o CGI continua relevante para tarefas que exigem a geração de programas externos ou ao executar scripts em linguagens não suportadas nativamente pelo servidor web. Um aspecto notável é a capacidade do Apache de lidar com scripts CGI de forma segura e eficiente, aproveitando os fortes mecanismos de isolamento de processos do Linux. Além disso, o Apache pode ser configurado para executar scripts CGI em praticamente qualquer linguagem de programação, tornando-o uma ferramenta incrivelmente versátil para geração de conteúdo dinâmico.

Instalação e configuração

Antes de começar a usar scripts CGI, você deve configurar o servidor web Apache e preparar seu ambiente para execução CGI. O processo envolve várias etapas detalhadas para garantir que o Apache esteja configurado corretamente para executar scripts CGI.

Instalando o Apache: Comece instalando o servidor web Apache em seu sistema Ubuntu. Abra seu terminal e digite o seguinte comando:
```
$ sudo apt update
$ sudo apt install apache2
```

Este comando atualiza sua lista de pacotes e instala o servidor web Apache 2. O Apache é pré-configurado com um site padrão e a capacidade de executar scripts CGI.

Habilitando o Módulo CGI: O Apache requer que o módulo CGI esteja habilitado para executar scripts CGI. Habilite este módulo executando:
```
$ sudo a2enmod cgi
```

Este comando habilita o módulo ‘cgi’, que é necessário para lidar com a execução do script CGI.

Configuração do Apache para CGI: Para executar scripts CGI escritos em várias linguagens como Python, Perl ou Bash, o Apache deve ser configurado para reconhecer e manipular esses arquivos adequadamente. Modifique o arquivo de configuração do Apache, que geralmente está localizado em /etc/apache2/sites-available/ ou diretamente no arquivo de configuração principal, dependendo da configuração do seu sistema. Adicione ou garanta que as seguintes configurações estejam presentes:
```
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory "/usr/lib/cgi-bin">
    AllowOverride None
    Options +ExecCGI
    AddHandler cgi-script .cgi .pl .py .sh .rb .go .js .php
    Require all granted
</Directory>
```

Esta configuração configura um caminho de URL que mapeia para o diretório onde os scripts CGI estão armazenados (ScriptAlias), permite a execução de scripts CGI no diretório especificado (Options +ExecCGI), informa ao Apache que arquivos com extensões como .cgi, .pl , .py, .sh, .rb, .go, .js e .php devem ser tratados como scripts CGI (AddHandler) e permitem que todos os usuários acessem os scripts CGI, que podem precisar ser restringidos com base em políticas de segurança ( Exigir tudo concedido).

Reinicie o Apache para aplicar as alterações: Depois de definir as configurações, reinicie o Apache para garantir que todas as alterações tenham efeito:
```
$ sudo systemctl restart apache2
```
Verificando a instalação do Apache: Para confirmar se o Apache foi instalado com sucesso e está em execução, você pode visitar o endereço IP do seu servidor em um navegador da web. Você deverá ver a página padrão do Apache Ubuntu.

Criação de scripts CGI

Depois que o Apache estiver configurado para executar scripts CGI, você poderá começar a criar scripts em várias linguagens de programação. Cada script deve ser executável e estar localizado no diretório CGI designado. Siga estas etapas detalhadas para criar scripts CGI usando Bash, Python, Perl e C/C++.

Criando um script Bash CGI: Comece com um script Bash simples que gera conteúdo HTML. Use seu editor de texto favorito para criar um arquivo chamado example-bash.sh no diretório /usr/lib/cgi-bin/.
```
#!/bin/bash
echo "Content-type: text/html"
echo ""
echo "<html><head><title>CGI Bash Example</title></head><body>"
echo "<h1>Hello from Bash CGI!</h1>"
echo "</body></html>"
```
Salve o script e torne-o executável:
```
$ sudo chmod +x /usr/lib/cgi-bin/example-bash.sh
```

Este script envia cabeçalhos HTTP e conteúdo HTML como saída, que é visualizada em um navegador da web.

Criando um script CGI em Python: os scripts em Python também podem servir a propósitos de CGI. Crie um arquivo chamado example-python.py no diretório /usr/lib/cgi-bin/.

#!/usr/bin/python3
print("Content-type: text/html\n\n")
print("<html><head><title>CGI Python Example</title></head><body>")
print("<h1>Hello from Python CGI!</h1>")
print("</body></html>")

Salve o script e torne-o executável:

$ sudo chmod +x /usr/lib/cgi-bin/example-python.py

Este script executa uma função semelhante ao script Bash, usando Python para gerar HTML.

Criando um script Perl CGI: Perl é outra linguagem popular para scripts CGI. Crie um arquivo chamado example-perl.pl no diretório /usr/lib/cgi-bin/.

#!/usr/bin/perl
print "Content-type: text/html\n\n";
print "<html><head><title>CGI Perl Example</title></head><body>";
print "<h1>Hello from Perl CGI!</h1>";
print "</body></html>";

Salve o script e torne-o executável:

$ sudo chmod +x /usr/lib/cgi-bin/example-perl.pl

Este script Perl envia HTML para o navegador, demonstrando como os scripts CGI funcionam em Perl.

Criando um script CGI C: C também pode ser utilizado para scripts CGI para lidar com tarefas de processamento mais complexas. Primeiro, certifique-se de que o compilador GCC esteja instalado em seu sistema:
```
$ sudo apt install gcc
```
Em seguida, crie um arquivo chamado example-c.c no diretório /usr/lib/cgi-bin/:
```
#include <stdio.h>
int main(void) {
    printf("Content-Type: text/html\n\n");
    printf("<html><head><title>CGI C Example</title></head><body>");
    printf("<h1>Hello from C CGI!</h1>");
    printf("</body></html>");
    return 0;
}
```
Compile o programa C para criar um executável adequado para processamento CGI:
```
$ sudo gcc -o /usr/lib/cgi-bin/example-c /usr/lib/cgi-bin/example-c.c
```

Esta etapa compila seu código-fonte C em um executável chamado example-c, que é armazenado no diretório CGI, permitindo que ele seja executado como um script CGI pelo servidor web. Este exemplo demonstra como gerar conteúdo HTML usando um programa C, compilado como um script CGI.

Ruby CGI Script: Ruby é uma linguagem de script fácil de usar, ideal para scripts rápidos. Primeiro, certifique-se de que o Ruby esteja instalado:
```
$ sudo apt install ruby
```
Crie um arquivo chamado example-ruby.rb no diretório /usr/lib/cgi-bin/:
```
#!/usr/bin/ruby
puts "Content-type: text/html\n\n"
puts "<html><head><title>CGI Ruby Example</title></head><body>"
puts "<h1>Hello from Ruby CGI!</h1>"
puts "</body></html>"
```
Salve este script e torne-o executável:
```
$ sudo chmod +x /usr/lib/cgi-bin/example-ruby.rb
```

Este script gera conteúdo HTML, semelhante aos exemplos anteriores, mas usando Ruby. fusível de dados="22189504506">

Script CGI Node.js: Node.js normalmente é usado para aplicativos de servidor completos, mas pode executar scripts CGI com configuração adequada. Instale o Node.js primeiro:

$ sudo apt-get install nodejs

Crie um arquivo chamado example-node.js no diretório /usr/lib/cgi-bin/:

#!/usr/bin/node
console.log("Content-type: text/html\n\n");
console.log("<html><head><title>CGI Node.js Example</title></head><body>");
console.log("<h1>Hello from Node.js CGI!</h1>");
console.log("</body></html>");

Torne o script executável:

$ sudo chmod +x /usr/lib/cgi-bin/example-node.js

Este exemplo usa JavaScript em um ambiente Node.js para fornecer conteúdo CGI.

Script PHP CGI: PHP também pode ser usado como um script CGI. Instale o PHP CLI se ainda não estiver disponível:

$ sudo apt install php-cli

Crie um arquivo chamado example-php.php no diretório /usr/lib/cgi-bin/:

#!/usr/bin/php
<?php
echo "Content-type: text/html\n\n";
echo "<html><head><title>CGI PHP Example</title></head><body>";
echo "<h1>Hello from PHP CGI!</h1>";
echo "</body></html>";

Altere o arquivo para executável:

$ sudo chmod +x /usr/lib/cgi-bin/example-php.php

Este script PHP irá gerar conteúdo HTML quando acessado através de um servidor web.

Go CGI Script: Go é conhecido por seu desempenho e eficiência. Instale o Go:

$ sudo apt install golang-go

Crie um script Go chamado example-go.go no diretório /usr/lib/cgi-bin/:

// File: example-go.go
package main
import "fmt"
func main() {
    fmt.Println("Content-type: text/html\n\n")
    fmt.Println("<html><head><title>CGI Go Example</title></head><body>")
    fmt.Println("<h1>Hello from Go CGI!</h1>")
    fmt.Println("</body></html>")
}

Compile o programa Go e torne o executável:

$ sudo go build -o /usr/lib/cgi-bin/example-go /usr/lib/cgi-bin/example-go.go

Este script usa Go para produzir saída HTML para fins CGI.

Tcl CGI Script: Tcl é outra linguagem de script adequada para scripts CGI. Instale o Tcl:

$ sudo apt install tcl

Crie um script Tcl chamado example-tcl.tcl no diretório /usr/lib/cgi-bin/:

#!/usr/bin/tclsh
puts "Content-type: text/html\n\n"
puts "<html><head><title>CGI Tcl Example</title></head><body>"
puts "<h1>Hello from Tcl CGI!</h1>"
puts "</body></html>"

Torne o script executável:

$ sudo chmod +x /usr/lib/cgi-bin/example-tcl.tcl

Este script demonstra capacidades CGI usando Tcl para gerar conteúdo HTML.

Testando scripts CGI

Depois de criar scripts CGI em várias linguagens de programação, é crucial testá-los para garantir que funcionam corretamente. Isso envolve acessar cada script por meio de um navegador da Web para verificar se eles são executados e renderizam a saída pretendida.

Acessando scripts CGI: Use seu navegador para navegar até cada script CGI que você criou. Por exemplo, para acessar um script Bash CGI, você pode usar:
```
http://cgi-example.local/cgi-bin/example-bash.sh
```

Da mesma forma, substitua example-bash.sh pelo nome de outros scripts, como example-python.py, example-perl.pl, example-ruby.rb, etc., para testar esses scripts.

Visualizando saídas CGI: Ao acessar as URLs dos seus scripts, seu servidor web os executa e envia sua saída como uma página web. Verifique a saída para garantir que ela seja exibida corretamente e reflita o que é esperado do script. Isso confirma que o script está funcionando corretamente e que o servidor está configurado corretamente para lidar com scripts CGI.

Conclusão

Embora possa ser visto como desatualizado, o CGI fornece uma maneira poderosa de integrar scripts de programação externos ao ambiente web para um gerenciamento eficaz do sistema. Seguindo este guia, você pode implantar scripts CGI para diversas tarefas administrativas e de monitoramento em seus servidores Linux.