wiki.franca.unesp.br - Recent changes [pt-BR]

Git

Guilherme — Wed, 20 May 2026 13:26:14 GMT

Created page with "= Guia Completo: Utilizando Git e GitHub do Zero = Bem-vindo(a) ao guia de uso básico do Git e GitHub! Este tutorial foi escrito para quem nunca teve contato com a ferrament..."

Página nova

= Guia Completo: Utilizando Git e GitHub do Zero =

Bem-vindo(a) ao guia de uso básico do Git e GitHub! Este tutorial foi escrito para quem nunca teve contato com a ferramenta. O Git é um sistema de controle de versão (como uma máquina do tempo para o seu código), e o GitHub é um site onde você guarda esse código na nuvem.

Neste tutorial, vamos cobrir o ciclo completo: pegar um código que já existe no seu servidor, colocar no GitHub, baixar no seu computador para editar, salvar as alterações e atualizar o servidor novamente.

== Pré-requisitos ==
* Ter uma conta criada no [https://github.com GitHub].
* Ter o Git instalado no servidor e no seu computador.
* Saber abrir o Terminal (Linux/Mac) ou o Prompt de Comando/PowerShell (Windows).

---

== Passo Zero: Protegendo suas Senhas (O arquivo .gitignore) ==
'''MUITO IMPORTANTE:''' Antes de enviarmos seu código do servidor para o GitHub, precisamos garantir que arquivos com senhas de banco de dados não sejam enviados. Se você enviar uma senha para um repositório público, qualquer pessoa na internet poderá ver!

Para isso, usamos um arquivo chamado <code>.gitignore</code>. Ele diz ao Git: ''"Ignore estes arquivos, não os envie para a nuvem"''.

# Acesse a pasta do seu projeto no servidor através do terminal.
# Crie um arquivo chamado <code>.gitignore</code> (com o ponto no início).
# Dentro dele, escreva o nome do arquivo que contém as suas senhas.

Por exemplo, se as suas configurações de banco de dados estão em um arquivo chamado <code>config.php</code> ou <code>.env</code>, você criaria e editaria o arquivo assim:

<pre>
nano .gitignore
</pre>
Dentro do arquivo, adicione a linha com o nome do arquivo a ser ignorado:
<pre>
config.php
</pre>
Salve e feche o arquivo. O Git agora fingirá que o <code>config.php</code> não existe!
== Situação 1: Do Servidor para o GitHub ==
Você tem o sistema rodando no servidor e quer guardar esse código no GitHub.
=== 1. Crie um Repositório no GitHub ===
Entre no site do GitHub e clique no botão verde '''"New"''' (Novo repositório).
Dê um nome ao seu projeto (ex: <code>meu-sistema</code>).
Escolha a visibilidade:
#* '''Public (Público):''' Qualquer um na internet pode ver seu código.
#* '''Private (Privado):''' Apenas você e quem você convidar podem ver. (Recomendado para sistemas de empresas).
'''NÃO''' marque as opções "Add a README file" ou "Add .gitignore". Deixe o repositório totalmente vazio.
Clique em '''Create repository'''.
=== 2. Envie o código do Servidor ===
No terminal do seu servidor, navegue até a pasta onde estão os arquivos do seu sistema e digite os comandos abaixo, um por um:
Inicia o Git na pasta do servidor:
<pre>
git init
</pre>
Adiciona todos os arquivos (menos os que estão no .gitignore) para serem salvos:
<pre>
git add .
</pre>
Cria um "pacote" com esses arquivos e dá uma mensagem a ele (isso se chama ''commit''):
<pre>
git commit -m "Primeiro envio do sistema"
</pre>
Muda o nome da ramificação principal para "main" (padrão atual do GitHub):
<pre>
git branch -M main
</pre>
Conecta a sua pasta local ao repositório que você criou no GitHub (Substitua a URL abaixo pela URL do seu repositório no GitHub):
<pre>
git remote add origin https://github.com/SEU_USUARIO/NOME_DO_REPOSITORIO.git
</pre>
Envia (''push'') o código para o GitHub:
<pre>
git push -u origin main
</pre>
'''Atenção para Repositórios Privados:'''
Ao fazer o comando <code>git push</code>, o GitHub pedirá seu usuário e senha. Hoje em dia, a "senha" não é a senha do site, mas sim um '''Personal Access Token (PAT)'''.
Vá no GitHub > Settings (Configurações) > Developer settings > Personal access tokens > Tokens (classic).
Gere um novo token marcando a caixinha "repo", copie esse código gigante e cole no terminal quando pedir a senha.
== Situação 2: Do GitHub para o seu Computador Local ==
Agora que o código está seguro no GitHub, você quer baixá-lo no seu computador para trabalhar usando o VSCode (ou Google Antigravity/ambiente web).
Abra o seu terminal no computador local e navegue até a pasta onde deseja salvar o projeto.
Digite o comando de "clonar" (copiar):
<pre>
git clone https://github.com/SEU_USUARIO/NOME_DO_REPOSITORIO.git
</pre>
O Git criará uma pasta com o nome do seu projeto.
Abra o VSCode, clique em '''File > Open Folder''' e selecione essa nova pasta.
'''Nota:''' Se o repositório for '''Privado''', o VSCode ou o terminal abrirá uma janelinha do navegador pedindo para você autorizar o acesso à sua conta do GitHub. É só clicar em autorizar.
'''Importante:''' Como você ignorou o arquivo de senha (ex: <code>config.php</code>) na Situação 1, ele não virá para o seu computador. Você precisará criar um <code>config.php</code> localmente com as senhas do seu banco de dados de teste (local).
== Situação 3: Atualizando o repositório após alterações locais ==
Você trabalhou no seu computador, modificou arquivos, criou novas funcionalidades no VSCode e agora quer mandar essas novidades de volta para o GitHub.
No terminal do seu computador (pode usar o terminal integrado do próprio VSCode), digite:
Adiciona todas as modificações que você fez:
<pre>
git add .
</pre>
Salva essas alterações com uma mensagem descrevendo o que foi feito:
<pre>
git commit -m "Adicionada tela de login e corrigido bug de layout"
</pre>
Envia as alterações para o GitHub:
<pre>
git push
</pre>
Pronto! Se você entrar no site do GitHub agora, verá que seus arquivos foram atualizados.
== Situação 4: Atualizando o código no Servidor ==
O GitHub já tem o código novo, mas o seu servidor (Situação 1) ainda está rodando o código antigo. Vamos puxar as novidades do GitHub para o servidor.
Acesse o terminal do seu servidor.
Vá para a pasta do seu sistema.
Digite o comando de "puxar" (''pull''):
<pre>
git pull origin main
</pre>
O Git irá baixar apenas os arquivos que foram modificados e atualizar seu sistema automaticamente!
Como nós protegemos o arquivo de senhas com o <code>.gitignore</code> no passo zero, o comando <code>git pull</code> '''não''' vai apagar ou sobrescrever as senhas do banco de dados de produção do seu servidor.
=== Resumo do Ciclo de Trabalho Diário ===
Daqui em diante, seu fluxo de trabalho sempre será este:
'''Trabalhar no Computador:''' <code>git add .</code> -> <code>git commit -m "mensagem"</code> -> <code>git push</code>
'''Atualizar o Servidor:''' <code>git pull origin main</code>

PXE Server

Guilherme — Thu, 30 Apr 2026 19:19:22 GMT

‎Passo 7: Configurando o Menu Customizado

Show changes

PXE Server

Guilherme — Thu, 30 Apr 2026 18:33:41 GMT

Created page with "= Servidor PXE Local com Netboot.xyz no Debian = Este guia detalha a implementação de um servidor de boot PXE local utilizando o '''netboot.xyz'''. A estrutura utiliza o Apa..."

Página nova

= Servidor PXE Local com Netboot.xyz no Debian =
Este guia detalha a implementação de um servidor de boot PXE local utilizando o '''netboot.xyz'''. A estrutura utiliza o Apache (HTTP) para transferência rápida de arquivos, TFTP para o boot inicial, Samba (SMB) para instalação automatizada do Windows e uma compilação customizada do iPXE para operar de forma 100% offline.
== Pré-requisitos ==
Antes de começar, atualize seu servidor Debian e instale todos os pacotes necessários:
<pre>
sudo apt update && sudo apt upgrade -y
sudo apt install -y apache2 tftpd-hpa samba wimtools genisoimage build-essential git liblzma-dev wget nano
</pre>
== Passo 1: Preparar o Servidor Web (Apache) e Baixar os Menus ==
Vamos criar a estrutura de pastas que vai hospedar as imagens e baixar os menus oficiais do netboot.xyz para o Apache local.
<pre>
# Criar diretórios do netboot e das categorias de imagens
sudo mkdir -p /var/www/html/netboot
sudo mkdir -p /var/www/html/assets/{Windows,Linux,Utilitarios}

# Acessar a pasta do netboot e baixar os menus
cd /var/www/html/netboot
sudo wget https://github.com/netbootxyz/netboot.xyz/releases/latest/download/netboot.xyz.tar.gz

# Extrair e limpar
sudo tar -xzf netboot.xyz.tar.gz
sudo rm netboot.xyz.tar.gz

# Ajustar permissões para o Apache
sudo chown -R www-data:www-data /var/www/html/
</pre>
== Passo 2: Configurar o Servidor TFTP ==
O TFTP é responsável por entregar os primeiros megabytes do boot. No Debian, o pacote <code>tftpd-hpa</code> utiliza o diretório <code>/srv/tftp</code> por padrão.
<pre>
# Garantir que o diretório exista
sudo mkdir -p /srv/tftp

# Reiniciar e habilitar o serviço
sudo systemctl restart tftpd-hpa
sudo systemctl enable tftpd-hpa
</pre>
== Passo 3: Compilar o iPXE Customizado ==
Para que o boot não dependa da internet, vamos compilar os arquivos de boot (EFI e BIOS) injetando um script que aponta diretamente para o IP do seu servidor Debian.
'''Atenção:''' Substitua <code>IP_DO_SEU_SERVIDOR</code> pelo endereço IP real da sua máquina Debian.
<pre>
cd ~
git clone https://github.com/ipxe/ipxe.git
cd ipxe/src

# Criar o script de redirecionamento (chainload)
cat <<EOF > boot.ipxe
#!ipxe
dhcp
chain http://IP_DO_SEU_SERVIDOR/netboot/menu.ipxe
EOF

# Compilar arquivo para máquinas antigas (Legacy/BIOS)
make bin/undionly.kpxe EMBED=boot.ipxe

# Compilar arquivo para máquinas novas (UEFI)
make bin-x86_64-efi/ipxe.efi EMBED=boot.ipxe

# Mover os arquivos gerados para o TFTP
sudo cp bin/undionly.kpxe /srv/tftp/
sudo cp bin-x86_64-efi/ipxe.efi /srv/tftp/
</pre>
== Passo 4: Configurar o Samba (Para Boot do Windows) ==
A instalação de Windows via rede exige mapeamento de disco na fase do Setup. O Samba compartilhará a pasta de arquivos do Windows.
Edite o arquivo de configuração do Samba:
<pre>
sudo nano /etc/samba/smb.conf
</pre>
Vá até o final do arquivo e adicione as seguintes linhas:
<pre>
[PXEWIN]
path = /var/www/html/assets/Windows
guest ok = yes
read only = yes
browseable = yes
</pre>
Reinicie o Samba para aplicar:
<pre>
sudo systemctl restart smbd
sudo systemctl enable smbd
</pre>
== Passo 5: Script de Automação para Extração do Windows ==
Este script extrai a ISO do Windows, baixa o injetor <code>wimboot</code> e modifica o <code>boot.wim</code> para montar o diretório Samba automaticamente e iniciar a instalação.
Crie o arquivo do script:
<pre>
cd ~
nano preparar_windows.sh
</pre>
Cole o conteúdo abaixo. '''Não se esqueça de alterar a variável IP_SERVIDOR''':
<pre>
#!/bin/bash

# ==========================================
# CONFIGURAÇÕES - ALTERE O IP ABAIXO
# ==========================================
IP_SERVIDOR="192.168.1.100"
DESTINO="/var/www/html/assets/Windows"
# ==========================================

ARQUIVO_ISO=$1
NOME_PASTA=$2
PASTA_WINDOWS="$DESTINO/$NOME_PASTA"

if [ -z "$ARQUIVO_ISO" ] || [ -z "$NOME_PASTA" ]; then
echo "Uso: sudo ./preparar_windows.sh <caminho_da_iso> <nome_da_pasta>"
echo "Exemplo: sudo ./preparar_windows.sh /home/usuario/win10.iso Win10"
exit 1
fi

echo "1. Criando pasta $PASTA_WINDOWS..."
mkdir -p "$PASTA_WINDOWS"

echo "2. Montando a ISO e copiando os arquivos..."
mkdir -p /mnt/iso_temp
mount -o loop "$ARQUIVO_ISO" /mnt/iso_temp
cp -r /mnt/iso_temp/* "$PASTA_WINDOWS/"
umount /mnt/iso_temp
rm -rf /mnt/iso_temp

echo "3. Baixando o arquivo wimboot oficial..."
if [ ! -f "$DESTINO/wimboot" ]; then
wget -qO "$DESTINO/wimboot" https://github.com/ipxe/wimboot/releases/latest/download/wimboot
fi

echo "4. Criando script de auto-conexao (startnet.cmd)..."
cat <<EOF > startnet.cmd
wpeinit
@echo Aguardando rede...
ping -n 5 127.0.0.1 >nul
@echo Conectando ao servidor $IP_SERVIDOR...
net use z: \\\\$IP_SERVIDOR\\PXEWIN\\$NOME_PASTA /user:nobody ""
z:\\setup.exe
EOF

echo "5. Injetando o script dentro do boot.wim..."
wimupdate "$PASTA_WINDOWS/sources/boot.wim" 2 <<EOF
add startnet.cmd /Windows/System32/startnet.cmd
EOF
rm startnet.cmd

echo "6. Ajustando permissoes..."
chmod -R 777 "$PASTA_WINDOWS"

echo "CONCLUIDO! Arquivos preparados com sucesso."
</pre>
Dê permissão de execução:
<pre>
chmod +x preparar_windows.sh
</pre>
'''Como usar:'''
<pre>sudo ./preparar_windows.sh /caminho/para/imagem-windows.iso Win11</pre>
== Passo 6: Preparando as Imagens Linux (Live CD) ==
Para o Linux funcionar como Live CD sem perder a conexão de rede:
Extraia a ISO do Linux (ex: Ubuntu).
Copie os arquivos <code>vmlinuz</code> (Kernel) e <code>initrd</code> (geralmente encontrados na pasta <code>casper</code> ou <code>boot</code>) para <code>/var/www/html/assets/Linux/</code>.
Copie a ISO inteira do Linux também para <code>/var/www/html/assets/Linux/ubuntu.iso</code>.
== Passo 7: Configurando o Menu Customizado ==
Edite o arquivo que gerencia o menu local do netboot:
<pre>
sudo nano /var/www/html/netboot/custom.ipxe
</pre>
Substitua tudo pelo código abaixo (altere o <code>IP_DO_SEU_SERVIDOR</code>):
<pre>
#!ipxe

# --- MENU PRINCIPAL ---
:custom_menu
clear custom_choice
menu Menu PXE Local - Debian
item --gap Selecione uma Categoria:
item menu_windows Instaladores Windows
item menu_linux Distribuicoes Linux (Live)
item menu_utils Ferramentas e Utilitarios
item --gap
item return Voltar ao Menu Anterior

choose custom_choice || goto custom_exit
goto ${custom_choice}

# --- SUBMENU WINDOWS ---
:menu_windows
clear win_choice
menu Instaladores Windows
item win11 Windows 11 (Automatizado)
item --gap
item custom_menu [ Voltar ]
choose win_choice || goto custom_menu
goto ${win_choice}

:win11
kernel http://IP_DO_SEU_SERVIDOR/assets/Windows/wimboot
initrd http://IP_DO_SEU_SERVIDOR/assets/Windows/Win11/boot/bcd bcd
initrd http://IP_DO_SEU_SERVIDOR/assets/Windows/Win11/boot/boot.sdi boot.sdi
initrd http://IP_DO_SEU_SERVIDOR/assets/Windows/Win11/sources/boot.wim boot.wim
boot || goto custom_menu

# --- SUBMENU LINUX ---
:menu_linux
clear lin_choice
menu Distribuicoes Linux
item ubuntu_live Ubuntu Live CD
item --gap
item custom_menu [ Voltar ]
choose lin_choice || goto custom_menu
goto ${lin_choice}

:ubuntu_live
kernel http://IP_DO_SEU_SERVIDOR/assets/Linux/vmlinuz
initrd http://IP_DO_SEU_SERVIDOR/assets/Linux/initrd
imgargs vmlinuz initrd=initrd ip=dhcp url=http://IP_DO_SEU_SERVIDOR/assets/Linux/ubuntu.iso
boot || goto custom_menu

# --- SUBMENU UTILITÁRIOS ---
:menu_utils
clear util_choice
menu Ferramentas e Utilitarios
item hirens Hirens BootCD PE
item --gap
item custom_menu [ Voltar ]
choose util_choice || goto custom_menu
goto ${util_choice}

:hirens
sanboot http://IP_DO_SEU_SERVIDOR/assets/Utilitarios/hirens.iso || goto custom_menu

# --- SAÍDA ---
:custom_exit
exit
</pre>
== Passo 8: Configuração do Servidor DHCP (Roteador/Firewall) ==
Para que os clientes da rede saibam onde buscar o boot, vá no seu servidor DHCP (Roteador, pfSense, Mikrotik, Windows Server) e configure as Opções de PXE:
'''Next-Server (Servidor TFTP):''' IP do seu Servidor Debian.
'''Boot Filename (Arquivo de Boot):'''
** Para máquinas UEFI: <code>ipxe.efi</code>
** Para máquinas Legacy/BIOS: <code>undionly.kpxe</code>
Acesse o Boot via Rede (F12) nos computadores clientes, entre na opção '''Custom Menu''' do painel do netboot e utilize o seu sistema de boot de forma totalmente local!