Como configurar Time and date no CentOS 7 (NTP)

NTP (Network Time Protocol) is a protocol which runs over port 123 UDP. NTP synchronize clients time and date with a master server.

This tutorial is about the client side configuration, but the server side configurations are not entirely different.

We are assuming that you have root permission, otherwise, you may start commands with “sudo”.

Install and configure NTP Daemon

NTP package is provided by default from RHEL repositories, and can be installed by the following command:

yum install ntp

To make sure that the appropriate time zone is configured on the server please execute below command.

 timedatectl

If you wish to change the timezone please follow following steps.

to get the list of all the available time zones:

 timedatectl list-timezones

To set your time zone you can use command below: (e.g. Los Angeles)

 timedatectl set-timezone America/Los_Angeles

Now you need to active the NTPD service at boot:

 systemctl enable ntpd
 systemctl start ntpd

To get a basic report you can use

 ntpstat

Or

 date

And to get some information about the time synchronization process

 ntpq -p

All of your NTP configurations are here:

 /etc/ntp.conf

 

Script Para Backup

Script Para Backup – Compactado com Tar e Gz, com Timestamp – Agendado via Cron

E aí pessoal,

Recentemente falei sobre um sistema de Backup para instalar em servidores, que funciona com comunicação client/server chamado Bácula. (Saiba mais sobre o Bácula: Sistema de Backup Open Source Bacula e Crie Seu Próprio Servidor de Backup com o Bacula).
E há também diversos outros sistemas de Backup gratuitos e pagos, que fazem isso.

Mas Hoje o Tutorial É Mais Simples!

Hoje passarei uma forma de automatizar seus backups de arquivos independentemente de sistemas sofisticados de backup.

“…vai que (…)”

robocop

Rotina Simples de Backup

Existe uma forma de automatizar seus backups de arquivos, através das ferramentas que já possui em seu Linux Desktop ou Server (como o Tar e o Cron), e sem gastar, nem instalar nada.
(Saiba mais sobre o Cron – (Agendador de Tarefas do Linux).

Já pensou nisso? Criar uma rotina de backup que:

  • Rodasse automaticamente em uma data e hora que você especificou;
  • Compactasse todo o conteúdo em um arquivo só, e ainda mais;
  • Colocasse no nome do arquivo a data do último backup realizado?

“Seus Problemas ‘Se Acabaram-Se”!!!

seu-creyssonHoje um tutorial simples sobre fazer backup de diretórios no Linux usando tarefas com tar (compactador) e cron (agendador).

Quase todos os Administradores Linux usam este método para fazer backup de seus dados críticos, que permite que você facilmente e rapidamente faça backup de seus arquivos ou todo o sistema.

Mas Antes de Começarmos…

Explicando TAR e Gzip

Vamos usar o TAR que empacota seus arquivos em um arquivo só, e depois, com o Gzip, para compactá-lo.

tar e gz

A Sintaxe é a seguinte:

# tar -cvpzf   /Diretório-Destino/nome-do-arquivo.tar.gz /Pasta-a-fazer-backup/pasta/

Exemplo:

Eu tenho diretório chamado “/dados-top” na raiz que está cheio de imagens, e eu quero fazer backup desse diretório, incluindo sub-diretórios e salvá-lo em um local diferente, como em /meubackup.

Então meu comando será:

# tar -cvpzf /meubackup/backup.tar.gz /dados-top

Saída do Comando:

tar4

Se estiver usando interface gráfica e quiser conferir.

Explicação dos parâmetros do Comando TAR:

  • tar = Tape archive.
  • c = Create.
  • v = Verbose mode.
  • p = Preserva os arquivos e as permissões dos diretórios.
  • z = Isto irá dizer ao tar para compactar os arquivos ainda mais para reduzir o tamanho do arquivo tar.
  • f = Este permite ao tar pegar o nome do arquivo.

Agora vamos criar um script bash com o comando tar nele.

Tutorial – Automatização do Backup

Para automatizarmos o backup iremos basicamente fazer isso em 2 passos.

1 – Criar um shell script de backup

2 – Agendarmos ele com o Cron

Agora sim! Vamos Lá?!

1 – Criando o Script de Backup

papiro

1 – Crie o script

Faça-o usando seu editor de texto favorito, como o vi, vim, nano, ou o gedit, e cole abaixo script.

# nano /backup.sh

Cole o Script abaixo no editor de texto.

#!/bin/bash
 #Propósito = Backup de Imagens em "/dados-top"
 #START
 TIME=`date +%b-%d-%y`         # Este comando irá adicionar a data no Nome do Arquivo de Backup.
 FILENAME=Backup-$TIME.tar.gz  # Aqui eu defino o formato do nome do arquivo de backup.
 SRCDIR=/dados-top             # Local Fonte     - onde estão os arquivos a serem feitos backup.
 DESDIR=/meubackup             # Local Destino - onde o Backup será salvo.
 tar -cpzf $DESDIR/$FILENAME $SRCDIR
 #END

Obs. No campo “TIME”, você pode editar o formato de data da maneira que quiser.
Se eu por exemplo preferir dia, mês, ano e então a hora seria assim:

TIME=`date +%d-%m-%Y-%H.%M`

O resultado final no nome do arquivo ficaria (se o dia fosse 07/12/2015 as 06:01 hs):

Backup-07-12-2015-06.01.tar.gz

Salve o arquivo (onde desejar), com o nome backup.sh (ou outro de sua preferência) e então feche o nano (ou o editor que estiver usando). No meu caso, o salvei na raiz também.
Se usou o nano, salve as modificações com o Ctrl+O, digite o nome e saia com Ctrl+X.

Este script irá fazer backup do diretório “/dados-top” e irá salvá-lo em um único arquivo compactado no diretório “/meubackup”.

OBS. CUIDADO COM O ESPAÇO

Este script não inclui apagar os backups antigos, então tome cuidado para não encher todo o disco do local determinado para salvar seu backup.
Existem maneiras de incluir no script comandos que apagam todos os backups anteriores, por exemplo, mais antigos que 2 meses, mas não inclui isso nesse tutorial.

2 – Dando Permissão e Testando

Permissão de execução

# chmod +x /backup.sh

Testando

Se quiser rodá-lo manualmente basta acessar a pasta onde o salvou e rodar com o comando “./backup.sh”

Acessarei a raiz onde o salvei;

# cd /

…e rodarei o script:

# ./backup.sh

Agora repare que ele irá fazer exatamente o que estamos querendo:

tar5

Se quiser checar pelo gerenciador de arquivos novamente.

O “Timestamp”, ou estampa de data, está no nome do arquivo.
Lembrando que hoje é dia 16 de Novembro.

tar6

 

2 – Agendando a Execução do Script no Cron

how_to_run_cron_job

Para configurar tarefas agendadas usaremos o comando “crontab -e”.
Este comando basicamente edita nosso arquivo de tarefas agendadas.

Quando você executar o comando “crontab -e” primeira vez, provavelmente ele irá pedir-lhe para escolher o editor de texto padrão, então, você só precisa selecionar seu editor favorito depois que ele nunca irá pedir-lhe novamente. No meu caso escolhi o “nano” que é a opção 2, e que como ele mostrou em “<—–easiest”, ou seja é o editor mais fácil de usar do que o vim ou o ed.

cron1

Exemplo de Agendamento

Vamos supor que eu quero executar este processo de backup em cada Segunda-feira e Sábado as 13:00 hs.

1 – Abra o utilitário de editor crontab:

crontab -e

2 – Role até o final do arquivo e cole as seguintes linha

# Agendamento do Backup "/dados-top"
 01 13 * * 1,6 /bin/bash /backup.sh

3 – Salve as modificações com o Ctrl+O, e saia com Ctrl+X

cron-config

Explicação da estrutura do Cron:

Minutos  |  Horas   |     Dia do Mês   |   Mês    |   Dia da Semana   |   Comando
0 to 59       0 to 23          1 to 31         1 to 12           0 to 6                  Comando em shell

CRONTAB2

 

2a Opção – Forma de Agendamento Ainda Menos Detalhado

Usando o comando “crontab -e” você criou um agendamento bem específico, mas se quiser fazer algo mais simples, ou seja, que rode de hora em hora, 1 vez semanalmente, mensalmente e assim por diante, existe um meio bem simples. E nesse caso, não use o “crontab -e”.

Apenas copie e cole seu script de backup em uma das pastas do cron específicas que o rodarão conforme o nome de cada pasta.
Temos as seguintes pastas na estrutura de arquivos do Cron:

cd /etc

cron.hourly      => de hora em hora
cron.daily         => diariamente
cron.weekly      => semanalmente
cron.monthly   => mensalmente

Basta colar seu script em uma delas de sua escolha e pronto.

Você pode usar também caracteres especiais no seu cron, como:

@reboot seu comando
@daily seu comando
@monthly seu comando

Então sempre que o dia virar, ou a cada mês ou reboot, o comando será executado.

Outros artigos que falam sobre o Cron:
http://www.cleuber.com.br/index.php/2014/06/24/agendador-de-tarefas-cron-no-linux
script-para-backup-compactado-com-tar-e-gz-com-timestamp-agendado-via-cron
como-usar-o-comando-rsync-para-transferir-dados-para-diretorios-locais-e-remotos

Visualizando o log de tarefas do Cron

Para ver se as tarefas rodaram adequadamente através da análise de logs, dê uma olhada neste artigo:
http://www.cleuber.com.br/index.php/2016/01/19/gerenciando-os-logs-do-cron

Conclusão

Em 2 passos, (criando um scrip e agendando no cron), você acabou de automatizar seus backups.
O script contém comandos que os empacota e os compacta através de do tar e gz, e salva-os com o nome que contém a data do backup. Muito chique não é mesmo?!
Isso pode ser aplicado em seu desktop com Linux ou em seus servidores.

E é só isso!

Abraços,

Cleuber

35 Usos Práticos do Comando Find

35 Usos Práticos do Comando Find

Olá pessoal.

Não tem como memorizar todos os comandos do Linux de uma vez só. Então o melhor a fazer é pesquisar e documentar, para que possamos consultar depois, quando não nos lembrarmos de algum comando, ou parâmetro.

Hoje aqui vou abordar o uso do comando find. Se você deseja ver o manual completo do find, basta digitar “man find” no terminal e ele mostrará o manual da ferramenta. Achei no site do tecmint, um bom resumo de 35 usos deste comando e vou repassar aqui. São exemplos práticos do uso do find.

Sobre o Find

O comando find é um dos comandos usados mais importantes no Linux. Ele é usado para pesquisar e listar arquivos e diretórios com base nas condições especificadas. O find pode ser usado com uma variedade de condições, como encontrar arquivos por permissões, usuários, grupos, tipo de arquivo, data, tamanho e outros critérios possíveis.

Ele pode também filtrar os resultados e então realizar uma ação sobre os arquivos encontrados, como por exemplo encontrar e excluir ou copiar ou fazer o que você desejar.

Para mostrar os 35 comandos find mais usados. Dividi a seção em cinco partes.

  1. Parte I: Encontrar arquivos pelos nomes
  2. Parte II: Encontrar arquivos com base em suas permissões
  3. Parte III: Encontrar arquivos com base em Usuários e Grupos
  4. Parte IV: Encontrar arquivos e diretórios com base na data e hora
  5. Parte V: Encontrar arquivos e diretórios com base no tamanho

Parte I – Encontrar Arquivos Pelos Nomes

Obs. Para você fazer esses exercícios na sua casa, precisará ter os mesmos arquivos de teste que usaremos aqui. Se preferir criá-los para reproduzir melhor o exercício, seria interessante. Eu faria isso com o comando touch para arquivos e mkdir para pastas.

touch receita.txt Receita.txt receita.php login.php index.php
mkdir Receita

1. Encontre arquivos usando o nome na pasta atual

Localizar todos os arquivos cujo nome é receita.txt na pasta de trabalho atual.

find . -name receita.txt

./receita.txt

2. Encontrar arquivos no diretório home

Localizar todos os arquivos dentro da pasta /home  com o nome receita.txt .

find /home -name receita.txt

/home/receita.txt

3. Localizar arquivos usando o nome e Ignorando o “case” (maiúsculas ou minúsculas)

Localizar todos os ficheiros cujo nome é receita.txt e contém letras maiúsculas e minúsculas no diretório /home.

find /home -iname receita.txt

./receita.txt
./Receita.txt

4. Encontrar Diretórios Usando Nome

Localizar todos os diretórios cujo nome é receita em /.

find / -type d -name Receita

/Receita

5. Localizar arquivos por formato. Ex: PHP

Encontrar todos os arquivos php cujo nome é receita.php no diretório de trabalho atual.

find . -type f -name receita.php

./receita.php

6. Localizar todos os arquivos PHP no diretório

Encontrar todos os arquivos php em um diretório.

find . -type f -name "*.php"

./receita.php
./login.php
./index.php

Parte II – Localizar Arquivos Com Base em suas Permissões

Obs. Para saber mais sobre permissões comuns, e permissões especiais, tais como as SGID, SUID e STICKY, consulte este outro artigo abaixo

chmod

7. Localizar arquivos com permissões 777.

find . -type f -perm 0777 -print

8. Encontre arquivos sem permissão 777.

find / -type f ! -perm 777

9. Localizar arquivos SGID com permissões 664.

find / -perm 2644

10. Localizar arquivos “Stick Bit” com permissões 551.

find / -perm 1551

11. Encontrar arquivos SUID.

find / -perm /u=s

12. Encontrar arquivos SGID.

Pesquisar os arquivos SGID .

find / -perm /g=s

13. Encontre Leia arquivos somente

Pesquisar os arquivos somente leitura.

find / -perm /u=r

14. Encontrar arquivos executáveis

Pesquisar os arquivos executáveis.

find / -perm /a=x

15. Encontrar arquivos com 777 permissões e chmod para 644

Encontrar todos os arquivos de permissão 777 e usar comando chmod para definir as permissões para 644.

find / -type f -perm 0777 -print -exec chmod 644 {} \;

16. Encontra Diretórios com Permissões 777 e fazer chmod para 755

Encontrar todos os diretórios com permissão 777 e usar chmod para definir as permissões para 755 .

find / -type d -perm 777 -print -exec chmod 755 {} \;

17. Encontrar e remover um único arquivo

Para encontrar um único arquivo chamado receita.txt e removê-lo.

find . -type f -name "receita.txt" -exec rm -f {} \;

18. Encontrar e remover vários arquivos por extensão

Para localizar e remover vários arquivos, como .mp3 ou .txt , em seguida, usar.

find . -type f -name "*.txt" -exec rm -f {} \;

Ou

find . -type f -name "*.mp3" -exec rm -f {} \;

19. Encontre todos os arquivos vazios

Para encontrar todos os arquivos vazios sob certo caminho.

find /tmp -type f -empty

20. Encontre todos os diretórios vazios

Para registrar todos os diretórios vazios sob certo caminho.

find /tmp -type d -empty

21. Arquivo todos os arquivos ocultos

Para encontrar todos os arquivos ocultos, use o comando abaixo.

find /tmp -type f -name ".*"

Parte III – Localizar arquivos com base em Proprietários e Grupos

22. Encontre único arquivo com base no usuário

Para encontrar todos os arquivos ou um único arquivo chamado receita.txt dentro da raiz “/”

find / -user root -name receita.txt

23. Localizar todos os arquivos com base no usuário

Para encontrar todos os arquivos que pertence ao usuário cleuber dentro da pasta /home.

find /home -user cleuber

24. Encontre todos os arquivos com base em Grupo

Para encontrar todos os arquivos que pertence ao grupo developer dentro da pasta /home.

find /home -group developer

25. Localizar arquivos particulares de um usuário

Para encontrar todos os arquivos .txt do usuário cleuber na pasta /home.

find /home -user tecmint -iname "*.txt"

Parte IV – Localizar arquivos e diretórios com base na data e hora

26. Encontre as últimas 50 Dias arquivos modificados

Para encontrar todos os arquivos que são modificados 50 dias atrás.

find / -mtime 50

27. Encontre arquivos acessados nos últimos 50 dias

Para encontrar todos os arquivos que foram acessados até 50 dias atrás.

find / -atime 50

28. Encontre os arquivos modificados entre 50 a 100 dias atrás

Para encontrar todos os arquivos que foram modificados mais de 50 dias para trás e menos de 100 dias.

find / -mtime +50 -mtime -100

29. Procurar arquivos alterados na última hora

Para encontrar todos os arquivos que foram alterados na última hora.

find / -cmin -60

30. Procurar arquivos modificados na última 1 hora

Para encontrar todos os arquivos que foram modificados na última hora.

find / -mmin -60

31. Procurar arquivos acessados na última 1 hora

Para encontrar todos os arquivos que foram acessados pela última vez na última hora.

find / -amin -60

Parte V – Localizar arquivos e diretórios com base no tamanho

32. Encontrar arquivos de 50MB

find / -size 50M

33. Encontre arquivos de tamanho entre 50MB a 100MB

Para encontrar todos os arquivos que são maiores do que 50 MB e menores de 100 MB.

find / -size +50M -size -100M

34. Localizar e apagar arquivos de 100MB

Para encontrar todos os arquivos de 100MB e excluí-los usando um único comando.

find / -size +100M -exec rm -rf {} \;

35. Procurar arquivos específicos e Excluir

Pesquisar os arquivos de extensão .mp3 com mais de 2MB e excluí-los usando um único comando.

find / -type f -name *.mp3 -size +2M -exec rm {} \;

Conclusão

Estes comandos find são extremamente úteis e com certeza em algum momento você precisará muito deles. Eu não usei outras ações do “-exec” aqui para os arquivos que foram encontrados, mas a sintaxe do exec para uma ação de cópia, após o comando find, por exemplo, seria:

-exec cp {} /pasta-destino \;

Exemplo – Encontrar arquivos mp3 e copiá-los para a pasta /tmp/musicas:

find . -type f -name "*.mp3" -exec cp {} /tmp/musicas \;

E a mesma regra se aplica para o comando de mover (mv).

Para saber mais dos comandos de Linux, um outro artigo talvez possa ser útil.

MySQL Replicação Master-Master

Configure MySQL Master-Master Replication

  • Last updated on: 2016-01-14
  • Authored by: Rackspace Support

Note: Rackspace Support cannot assist with master-master replication setups due to the complexity of configuration and likelihood of error. As an alternative to direct MySQL master-master replication, consider either our Cloud Databases service or a replication engine like Tungsten for more reliable data replication between database instances.

MySQL Master-Master Replication

This article is about setting up MySQL Master-Master database replication between two Cloud Servers. Master-Master data replication allows for replicated data, stored on multiple computers, to be updated by any authorized contributing member of the group. This allows for more open collaboration than Master-Slave replication where any needed changes identified by a group member must to be submitted to the designated “master” of the node.

The operating system we will use is Debian 5 (Lenny), built from the Rackspace Cloud base image.

Setup Outline

We will have two Cloud Servers, named debian501 and debian502 for the purpose of this exercise. Both servers have two IP addresses (one public, one private). We will configure the replication to be done over the private IP interface so that we don’t incur any bandwidth charges.

Creating the Cloud Servers

You will need to create two Linux Cloud Servers, using the Debian 5 base image. Use the following steps to create each server separately.

  1. Log in to the Cloud Control Panel.
  2. On the Cloud Servers page, click Create Server.
  3. Name the servers so that you can easily identify them during setup. In this exercise they are named debian501 and debian502.
  4. Select the Debian image.
  5. Select the RAM configuration (flavor) meets your database requirements.
  6. Click Create Server.

Note that the commands listed below are to be run as a privileged (root, sudo group) user.

Installing MySQL

First we need to install MySQL on both the Debian Cloud Servers. As always, prior to installing any packages, we need to make sure that our package list is up to date and our locale/language settings are configured properly.

  • Update the package database:
    # aptitude update
    
  • Install locales:
    # aptitude install locales
    
    # dpkg-reconfigure locales
    
  • The dpkg-reconfigure locales command will bring up a locales setting window where you can choose the locales for your system depending on your country and region. In this case we have chosen en_GB.UTF-8.
  • Now, you can run the following commands to install MySQL:
    # aptitude install mysql-server mysql-client libmysqlclient15-dev
    

Configuring replication

Once the mysql-server package has been installed successfully, we can start configuring each of the MySQL nodes in order to enable replication between them.

We need to create the database that will be replicated as well as the replication username and password to be used with it. You can use the commands outlined below to set them up, remembering to change all the strings/values in brackets to apply to your specific configuration.

  • First on debian501, login to the mysql console (using mysql root password setup during MySQL installation).
    # mysql -u root -p
    mysql>
    
  • Now let’s create the replication user, which will be used to synchronize the changes.
    mysql> grant replication slave on \*.\* to slaveuser@'[private IP of debian502]' identified by '[some password]';
    mysql> flush privileges;
    mysql> exit
    
  • Do the same for debian502
    mysql> grant replication slave on \*.\* to slaveuser@'[private IP of debian501]' identified by '[some password]';
    mysql> flush privileges;
    mysql> exit
    
  • Back on debian501, edit /etc/mysql/my.cnf and insert/update or uncomment following entries:
    bind-address = 0.0.0.0
    server-id = 1
    log-bin = /var/log/mysql/var/bin.log
    log-slave-updates
    log-bin-index = /var/log/mysql/log-bin.index
    log-error = /var/log/mysql/error.log
    relay-log = /var/log/mysql/relay.log
    relay-log-info-file = /var/log/mysql/relay-log.info
    relay-log-index = /var/log/mysql/relay-log.index
    auto_increment_increment = 10
    auto_increment_offset = 1
    master-host = [private IP address of debian502]
    master-user = [replication username]
    master-password = [replication password]
    replicate-do-db = <database name to be replicated>
    
  • Repeat the steps on the debian502 server
    bind-address = 0.0.0.0
    server-id = 2
    log-bin = /var/log/mysql/bin.log
    log-slave-updates
    log-bin-index = /var/log/mysql/log-bin.index
    log-error = /var/log/mysql/error.log
    relay-log = /var/log/mysql/relay.log
    relay-log-info-file = /var/log/mysql/relay-log.info
    relay-log-index = /var/log/mysql/relay-log.index
    auto_increment_increment = 10
    auto_increment_offset = 2
    master-host =  [private IP address of debian501]
    master-user = [replication username]
    master-password = [replication user password]
    replicate-do-db = [database name to be replicated]
    
  • Now, restart both databases. If the service restart on either server fails, then please check the /var/log/mysql/error.log file for any errors. Update the configuration and check for any typos, etc.,

Testing the scenarios

For the purpose of testing our replication setup, we can create the database specified in the configuration section above, as well as a test table on one of the nodes and watch the log files in /var/log/mysqldirectory. Note that all database changes should be replicated to our other server immediately.

  mysql> create database [your-db-name];
  mysql> use [your-db-name]
  mysql> create table foo (id int not null, username varchar(30) not null);
  mysql> insert into foo values (1, 'bar');
  • An additional test is to stop the MySQL service on debian502, making database changes on the debian501 server and then restarting the MySQL service on debian502. The debian502 MySQL service should sync up all the new changes automatically.
  • You should also consider changing the default binary log rotation values (expire_logs_days and max_binlog_size) in the /etc/mysql/my.cnf file, as by default all the binary logs will be kept for 10 days. If you have high transaction count on your database application then it can cause significant hard disk space usage in logs. So, we recommend changing those values to match your server backup policies. For example, if you have daily backups setup of your MySQL node then it makes no sense to keep 10 days worth of binary logs.

GIT – Guia Prático

criando um novo repositório

crie uma nova pasta, abra-a e execute o comando
git init
para criar um novo repositório.

obtenha um repositório

crie uma cópia de trabalho em um repositório local executando o comando
git clone /caminho/para/o/repositório
quando usar um servidor remoto, seu comando será
git clone usuário@servidor:/caminho/para/o/repositório

fluxo de trabalho

seus repositórios locais consistem em três “árvores” mantidas pelo git. a primeira delas é sua Working Directory que contém os arquivos vigentes. a segunda Index que funciona como uma área temporária e finalmente a HEAD que aponta para o último commit (confirmação) que você fez.

adicionar & confirmar

Você pode propor mudanças (adicioná-las ao Index) usando
git add <arquivo>
git add *
Este é o primeiro passo no fluxo de trabalho básico do git. Para realmente confirmar estas mudanças (isto é, fazer um commit), use
git commit -m "comentários das alterações"
Agora o arquivo é enviado para o HEAD, mas ainda não para o repositório remoto.

enviando alterações

Suas alterações agora estão no HEAD da sua cópia de trabalho local. Para enviar estas alterações ao seu repositório remoto, execute
git push origin master
Altere master para qualquer ramo (branch) desejado, enviando suas alterações para ele.

Se você não clonou um repositório existente e quer conectar seu repositório a um servidor remoto, você deve adicioná-lo com
git remote add origin <servidor>
Agora você é capaz de enviar suas alterações para o servidor remoto selecionado.

ramificando

Branches (“ramos”) são utilizados para desenvolver funcionalidades isoladas umas das outras. O branch master é o branch “padrão” quando você cria um repositório. Use outros branches para desenvolver e mescle-os (merge) ao branch master após a conclusão.

crie um novo branch chamado “funcionalidade_x” e selecione-o usando
git checkout -b funcionalidade_x
retorne para o master usando
git checkout master
e remova o branch da seguinte forma
git branch -d funcionalidade_x
um branch não está disponível a outros a menos que você envie o branch para seu repositório remoto
git push origin <funcionalidade_x>

atualizar & mesclar

para atualizar seu repositório local com a mais nova versão, execute
git pull
na sua pasta de trabalho para obter e fazer merge (mesclar) alterações remotas.
para fazer merge de um outro branch ao seu branch ativo (ex. master), use
git merge <branch>
em ambos os casos o git tenta fazer o merge das alterações automaticamente. Infelizmente, isto nem sempre é possível e resulta em conflitos. Você é responsável por fazer o merge estes conflitosmanualmente editando os arquivos exibidos pelo git. Depois de alterar, você precisa marcá-los como merged com
git add <arquivo>
antes de fazer o merge das alterações, você pode também pré-visualizá-as usando
git diff <branch origem> <branch destino>

rotulando

é recomendado criar rótulos para releases de software. Este é um conhecido conceito, que também existe no SVN. Você pode criar um novo rótulo chamado 1.0.0 executando o comando
git tag 1.0.0 1b2e1d63ff
o 1b2e1d63ff representa os 10 primeiros caracteres do id de commit que você quer referenciar com seu rótulo. Você pode obter o id de commit com
git log
você pode também usar menos caracteres do id de commit, ele somente precisa ser único.

sobrescrever alterações locais

No caso de você ter feito algo errado (que seguramente nunca acontece 😉 ) você pode sobrescrever as alterações locais usando o commando
git checkout -- <arquivo>
isto substitui as alterações na sua árvore de trabalho com o conteúdo mais recente no HEAD. Alterações já adicionadas ao index, bem como novos arquivos serão mantidos.

Se ao invés disso você deseja remover todas as alterações e commits locais, recupere o histórico mais recente do servidor e aponte para seu branch master local desta forma
git fetch origin
git reset --hard origin/master

dicas úteis

Interface gráfica padrão
gitk
usar saídas do git coloridas
git config color.ui true
exibir log em apenas uma linha por commit
git config format.pretty oneline
fazer inclusões interativas
git add -i

Cron Jobs e Logs

Olá pessoal, aqui uma dica bem rápida.

Já expliquei bastante sobre a importância que o Cron tem nos sistemas Unix-like, para agendar tarefas, scripts e comandos.

Agora, muitas vezes, precisamos saber se um determinado job rodou adequadamente, durante a noite por exemplo. Para isso, precisamos analisar o log.

Por padrão o syslog, (serviço do sistema que grava os logs), não salva os logs do cron em um arquivo dedicado.

Ele salva os logs do cron no arquivo /var/log/syslog, juntamente com outras informações do sistema.

Visualizando os Logs do Cron

Uma maneira inicial de visualizar e de filtrar os logs do cron contidos no arquivos de log (/var/log/syslog), é através do comando:

grep CRON /var/log/syslog

Este comando irá mostrar os jobs de todos os usuários.

Visualizando os Logs de Um Usuário Específico

Para mostrar apenas os jobs de um determinado usuário use este comando:

grep CRON.*\(usuário\) /var/log/syslog

Pesquisando Pelo Comando ou Script do Job

Para saber se um script específico que você agendou no cron, rodou, você pode procurar pelo comando ou script. Digamos que nosso script se chama backup.sh:

grep "backup.sh" /var/log/syslog

A saída do comando deve ser parecida com a abaixo, (e ela colocará cor no palavra-chave que você pesquisou usando o grep), e sempre nessa ordem:
Data / Nome da máquina / Nome do Processo e PID: usuário / comando

Jan 21 08:00:01 MEU_SERVER CRON[44553]: (suporte) CMD (/home/suporte/scripts/backup.sh)

Assim você saberá que as 8:00hs do dia 21 de Janeiro o comando/script “backup.sh” rodou usando o usuário suporte através do processo do cron no pid 44553.

Saber Se Um Job do Cron Rodou Em Um Horário Específico

O comando abaixo irá filtrar os jobs do cron que rodaram as 08 horas.

grep CRON “08:” /var/log/syslog | head -10

A saída deverá ser como

/var/log/syslog:Jan 21 08:00:01 SFL01 CRON[44553]: (usuário tal) CMD (comando tal)
/var/log/syslog:Jan 21 08:09:02 SFL01 CRON[47130]: (usuário tal) CMD (comando tal)
(…) e assim por diante

Habilitando Os Logs do Cron Também No Caminho /var/log/cron

Em 2 Passos

Passo 1 – Edite o arquivo abaixo com o seguinte comando.

nano /etc/rsyslog.d/50-default.conf

E então descomente a linha que aparece “#cron*”.
Observe abaixo que a linha está comentada (com o símbolo # antecedendo as letras)

log1

Observe abaixo que agora, eu já a descomentei.

log2

Passo 2 – Agora basta reiniciar o rsyslog com o comando:

sudo service rsyslog restart

log3

Checando os Logs do Cron No Caminho Habilitado: /var/log/cron.

Pronto, agora adicionalmente ao syslog, os logs do cron também estarão registrados no arquivo var/log/cron.log

Para checá-los, basta visualizar este aquivo com cat ou com tail, (o tail mostra apenas as últimas linhas).

tail /var/log/cron.log

Editando Uma Tarefa do Cron Para Gravar Seu Log Em Um Outro Local e Arquivo Específico

Você pode direcionar a saída das tarefas individuais agendadas no cron, aos seus próprios registros para melhorar a legibilidade. Você só precisa especificar um arquivo de saída, redirecionando-o através do uso do símbolo “>”. Use o comando “crontab -e” para começar a editar suas tarefas.

Isso irá reescrever o arquivo de saída cada vez.
Se você gostaria de acrescentar a saída no final do arquivo em vez de uma reescrita completa, use colchete de fechamento duplo “>>”

 0 15 * * * /home/cleuber/backup-diario.sh >> /home/cleuber/logs/backup-diario.log 2>&1

Acima vemos um cron que as 15:00hs, diariamente, roda um script chamado “backup-diario.sh” e seu log será armazenado em /homer/cleuber/logs/backup.log. (ou seja numa pasta chamada “logs” que criei em minha pasta “Home/pasta pessoal”.
(Para que sejam redirecionadas as saídas normais e saídas dos erros, ambas para o mesmo arquivo de log especificado, usei os parâmetros “2>&1”).

Legal não é?!

Registrando e Verificando o Tempo de Execução de Um Job do Cron

Registrando No Job:

Se você deseja saber o tempo que levou para concluir a execução de uma tarefa que rodou.
Imagine uma tarefa que faça o rsync de pasta entre dois servidores, ou faz a compactação de uma pasta com muitos gigabites de dados, e você quer saber quanto tempo a tarefa levou para terminar.

Então, para isso funcionar, você pode adicionar o parâmetro “time” antes do comando no cron.

Exemplo (registrando um arquivo de log em outro destino, e registrando a duração):

0 15 * * * time /home/cleuber/backup-diario.sh >> /home/cleuber/logs/backup-diario.log 2>&1

Obs. Lembre-se que o direcionamento da saída usando o símbolo “>” cria um arquivo de log e sobrescreve-o a cada execução do script, já usando dois símbolos “>>”, ele irá adicionando as saídas ao mesmo arquivo, criando uma lista que vai crescendo a cada execução. Lembre-se também que o parâmetro no final da linha “2>&1” coloca no arquivo as saídas que deram errado e as que deram certo, ok?

Visualizando o Tempo Decorrido:

A saída do tempo decorrido virá com dados de user e de system, mas o que a gente quer é o “elapsed” (traduzindo – “duração”).

Então se eu der um comando para visualizar o arquivo de log, ou seja, um cat (que mostra o arquivo todo), ou um tail (e usar o “-6” para mostrar as últimas 6 linhas), neste caso de exemplo:

tail -6 /home/cleuber/logs/backup-diario.log

Suponhamos que este script “backup-diario.sh”, por exemplo, compacte, usando o tar, dois arquivos (conteudo1.txt e conteudo2.txt) de uma pasta, então, podemos ver no log a saída desta forma:

tar: Removendo `/' inicial dos nomes dos membros
/home/suporte/Documentos/teste/
/home/suporte/Documentos/teste/conteudo.txt
/home/suporte/Documentos/teste/conteudo2.txt
1.16user 0.03system 0:01.20elapsed 98%CPU (0avgtext+0avgdata 5600maxresident)k
59840inputs+56496outputs (0major+826minor)pagefaults 0swaps

Reparou que na penúltima linha de saída, eu tenho o tempo de duração da tarefa (elapsed)?
Então, vemos que levou 1 minuto e 20 segundos.

Se preferir filtrar apenas o tempo de duração:

tail -6 /home/cleuber/logs/backup-diario.log | grep elapsed

A saída filtrada será como esta:

0.00user 0.00system 0:01.20elapsed

Obs. Apenas para reforçar – Usamos o “tail -6” porque pega o final do arquivo e queremos ver a última execução, mas você poderia usar um “cat”, caso, queira ver todas as durações de todas as tarefas que rodaram, ou no caso de estar usando o símbolo “>”, (ou invés do “>>”), o que faz ele sobrescrever o arquivo, então ele não gerará uma lista, e sim apenas o registro da última execução, então o cat, pode ser usado para mostrar porque vai ter apenas uma linha com o conteúdo “elapsed” que queremos. Mas aí fica ao seu critério.

Enviando o Log do Cron Para Um Endereço de E-mail

Pré-requisito

Primeiramente, um requisito é ter o pacote do postfix instalado.
Ao rodar um comando com parâmetro para enviar o log para um e-mail, e você não tiver o postfix instalado, o Linux em alguns casos poderá te alertar a instalar este pacote primeiro.
No caso do Ubuntu é assim. Então instale-o através do comando:

sudo apt-get install mailutils

Ele irá exibir dois passos ou telas, a primeira, você poderá deixar como “Site Internet” e a segunda o nome do seu domínio (pode deixar como está mesmo).

Feito isso, embora não usaremos este Linux como servidor de e-mails, ele já poderá encaminhar mensagens de e-mail para um endereço de e-mail comum como o gmail, hotmail, e etc, você que desejar.

Para todos os crons da sua conta:

Edite o cron, com o comando “crontab -e” e depois adicione a seguinte linha no começo do arquivo:

MAILTO=sua-conta@seu-email.com

Para Conta Nenhuma

Se quiser que ele não envie e-mail para lugar nenhum, nem para o local (/var/mail/sua-conta) basta deixar vazio.

MAILTO=""

Para Um E-mail Específico apenas em Um Job Específico

0 15 * * * time /home/cleuber/backup-diario.sh  | mail -s "Status do Backup" sua-conta@seu-e-mail.com

Não Criando Logs de Uma Tarefa do Cron

Se você deseja que uma tarefa do Cron, não gere nenhum tipo de saída de logs, basta deixar o job assim:

0 15 * * * time /home/cleuber/backup-diario.sh  > /dev/null 2>&1

Obs. Outros lugares que checamos os logs do cron:

/var/mail/seu usuário – aqui pode-se ver também o tempo de execução
/var/log/syslog – aqui vemos os logs de execução do cron
/var/log/cron – aqui vemos os logs de execução do cron

Outros artigos que falam sobre o Cron:
http://www.cleuber.com.br/index.php/2014/06/24/agendador-de-tarefas-cron-no-linux
script-para-backup-compactado-com-tar-e-gz-com-timestamp-agendado-via-cron
como-usar-o-comando-rsync-para-transferir-dados-para-diretorios-locais-e-remotos

Menu Dinâmico com PHP e Boostrap

 In part 1, we prototyped the end product and wrote the main Menu class, which serves as the menu manager – a container to hold all sub-units (items and links). In this part, we’ll build the remainder of the classes and demonstrate the menu builder’s usage.

Item

Represents our menu items as independent objects.

Create a new file called item.php and paste in the following code:

item.php

class Item {
	
	protected $manager;
	protected $id;
	protected $pid;
	protected $meta;
	protected $attributes = array();
	
	public    $link;
	
	//...
  • $manager stores a reference to the menu manager (Menu object). This makes us able to use menu manager methods within Item context.
  • $id stores the item’s id.
  • $pid stores item’s parent id if it has one otherwise it’ll be set to null.
  • $meta an array for storing extra data with each item.
  • $attributes an array of HTML attributes.
  • $link stores an instance of class Link.

__construct(manager, title, url, attributes, pid)

Initializes the attributes.

public function __construct($manager, $title, $url, $attributes = array(), $pid = 0)
{
	$this->manager     = $manager;
	$this->id          = $this->id();
	$this->pid         = $pid;
	$this->title       = $title;
	$this->attributes  = $attributes;
	
	// Create an object of type Link
	$this->link        = new Link($title, $url);
}

add(title, options)

Class Item has an add() method as well (just like the menu manager). In fact this method doesn’t create items on its own. It gets the arguments, adds a pid key to $options and calls add() of the menu manager.

public function add($title, $options)
{
	if( !is_array($options) ) {
			$options = array('url' => $options);
		}
		
	$options['pid'] = $this->id;
				
	return $this->manager->add( $title, $options );
}

This gives us the power to create sub items in a more semantic way rather than explicitly defining a pid:

$menu = new Menu;
	
	$about = $menu->add('About', 'about');
	
	// We write it this way
	$about->add('What we do?', 'what-we-do');
	
	// instead of:
	// $menu->add('What we do?', array('url' => 'what-we-do', 'pid' => $about->get_id()));

id()

Generates a unique id for the Item. We use this identifier to refer to the item later.

protected function id()
{
	return $this->manager->length() + 1;
}

In fact id() calls length() of the menu manager and increments it by 1.

get_id()

We also need to create a getter method to return the id when needed:

public function get_id()
{
	return $this->id;
}

get_pid()

Items might have pid (parent’s id). pid value might be null or id of another item.

Items with pid set to null are the items at root level.

We need to create a getter to return Item’s pid as well:

public function get_pid()
{
	return $this->pid;
}

hasChildren()

Checks whether the item has any children or not.

public function hasChildren()
{
	return (count($this->manager->whereParent($this->id))) ? true : false;
}

It calls whereParent() via the manager.

children()

Fetches children of the item.

public function children()
{
	return $this->manager->whereParent($this->id);
}

attributes(key, value)

Gets or sets item’s attributes.

public function attributes()
{
	$args = func_get_args();

	if(is_array($args[0])) {
		$this->attributes = array_merge($this->attributes, $args[0]);
		return $this;
	}
	
	elseif(isset($args[0]) && isset($args[1])) {
		$this->attributes[$args[0]] = $args[1];
		return $this;
	} 
	
	elseif(isset($args[0])) {
		return isset($this->attributes[$args[0]]) ? $this->attributes[$args[0]] : null;
	}
	
	return $this->attributes;	
}

As you see attributes() returns different types of results according to the arguments given:

  • Sets attribute if both $key and $value given.
  • Sets array of attributes if $key is an array.
  • Gets attribute if only $key given.
  • Gets all attributes if no argument given.

meta($key, $value)

Meta stores extra data about the item. It can be any kind of data from placement order to required permissions.

public function meta()
{
	$args = func_get_args();

	if(is_array($args[0])) {
		$this->meta = array_merge($this->meta, $args[0]);
		return $this;
	}
	
	elseif(isset($args[0]) && isset($args[1])) {
		$this->meta[$args[0]] = $args[1];
		return $this;
	} 
	
	elseif(isset($args[0])) {
		return isset($this->meta[$args[0]]) ? $this->meta[$args[0]] : null;
	}
	
	return $this->meta;
}

meta() works exactly like attributes().

Now let’s move on to the Link class.

Class Link is a simple class consisting of several getter and setter methods.

Link has three attributes:

  • text link text
  • url link URL
  • attributes link attributes

link.php

class Link {
	
	public $text;
	public $url;
	public $attributes;

	//....

__construct(text, url, attributes)

When we create an object of type Link, the constructor method binds the arguments to the attributes listed above:

public function __construct($text, $url, $attributes = array())
{
	$this->text = $text;
	
	$this->url = $url;
	
	$this->attributes = $attributes;
}

string get_url()

Returns link url.

public function get_url()
{
	return $this->url;
}

string get_text()

Returns the link text

public function get_text()
{
	return $this->text;
}

You’ll encounter situations when you need to append or prepend some content to the anchor text like a caret sign for drop-downs or a graphical icon. To achieve this, we will create two simple functions that do just the thing for us.

append(content)

append adds content to the link text:

public function append($content)
{
	$this->text .= $content;
	
	return $this;
}

prepend(content)

prepend prepends content to the link:

public function prepend($content)
{
	$this->text = $content . $this->text;
	
	return $this;
}

attributes(key, value)

Like Items It would be fantastic if we could define HTML attributes for anchors.

public function attributes($key = null, $value = null)
{
	$args = func_get_args();

	if(is_array($args[0])) {
		$this->attributes = array_merge($this->attributes, $args[0]);
		return $this;
	}
	
	elseif(isset($args[0]) && isset($args[1])) {
		$this->attributes[$args[0]] = $args[1];
		return $this;
	} 
	
	elseif(isset($args[0])) {
		return isset($this->attributes[$args[0]]) ? $this->attributes[$args[0]] : null;
	}
	
	return $this->attributes;
}

I think this method is familiar to you since we’ve created it earlier.

With this, our Menu Builder is complete!

 

Usage

We usually create one PHP file per class definition, so, to use our menu builder we need to include each file at the beginning of our script.

Rather than including all the three files, I’m going to take advantage of class autoloading feature in PHP: __autoload(string $class). This feature helps us avoid writing a long list of includes at the beginning of each script.

__autoload() is automatically called in case you are trying to use a class or interface which hasn’t been defined yet.

__autoload receives the class name as argument.

This is how we’re going to use it:

function __autoload($class) {
	require_once(strtolower($class) . '.php');
}

Name this file autoload.php and include it in your script.

Please note that this is probably less than ideal. In a real project, your autoloading needs would be taken care of by Composer or the framework’s autoloader. You can see this on the Github link we provided – the project is fully developed there, and fine tuned for use with Laravel, among others.

Next, let’s create a menu to test our menu builder out:

<?php
require_once('autoload.php');

$menu = new Menu;

$about = $menu->add('About', 'about');

// since this item has sub items we append a caret icon to the hyperlink text
$about->link->append(' <span class="caret"></span>');

// we can attach HTML attributes to the hyper-link as well
$about->link->attributes(['class' => 'link-item', 'target' => '_blank']);

// Adding an attribute to the item wrapper itself
$about->attributes('data-model', 'info');

$about->add('Who we are?', array('url' => 'who-we-are',  'class' => 'navbar-item whoweare'));
$about->add('What we do?', array('url' => 'what-we-do',  'class' => 'navbar-item whatwedo'));

$about->add('Goals', array('url' => 'goals', 'display' => false));

$menu->add('Portfolio', 'portfolio');
$menu->add('Contact',   'contact');

// we're only going to hide items with `display` set to **false**

$menu->filter( function($item){
	if( $item->meta('display') === false) {
		return false;
	}
	return true;
});

// Now we can render the menu as various HTML entities:

echo $menu->asUl( attribute('class' => 'ausomw-ul') );

//OR

echo $menu->asOl( attribute('class' => 'ausomw-ol') );

// OR

echo $menu->asDiv( attribute('class' => 'ausomw-div') );

?>

Done!

Bootstrap 3 Navbar

The final step is to use our menu builder to create dynamic Bootstrap Navbars.

First of all, we need to create a function that populates our items in a Bootstrap friendly format because the existing render method doesn’t do this for us.

I name this function bootstrapItems() (I couldn’t really think of a better name, feel free to name it whatever you please).

You can put this function in any file you like as long as it is loaded at application startup. Alternatively you can extend the class Menu and add this method to the class. In this example, I place it in autoloader.php (as a helper function) to make sure it is always available to me.

function bootstrapItems($items) {
	
	// Starting from items at root level
	if( !is_array($items) ) {
		$items = $items->roots();
	}
	
	foreach( $items as $item ) {
	?>
		<li <?php if($item->hasChildren()): ?> class="dropdown" <?php endif ?>>
		<a href="<?php echo $item->link->get_url() ?>" <?php if($item->hasChildren()): ?> class="dropdown-toggle" data-toggle="dropdown" <?php endif ?>>
		 <?php echo $item->link->get_text() ?> <?php if($item->hasChildren()): ?> <b class="caret"></b> <?php endif ?></a>
		<?php if($item->hasChildren()): ?>
		<ul class="dropdown-menu">
		<?php bootstrapItems( $item->children() ) ?>
		</ul> 
		<?php endif ?>
		</li>
	<?php
	}
}

Since it’s just for educational purpose I didn’t use a template engine here as It’s beyond the scope of this tutorial. You can use the template engine of your choice to separate logic from presentation and make your code more readable.

Let’s see what BootstrapItems does behind the scenes.

First of all, it checks whether the given argument is an array or not. If it’s not, it fetches the items at root level and iterates over them. On each iteration it checks also if the current element has any children and if the element does have children, it will call itself passing the element’s children as a parameter. This process is repeated until it renders all the items to the deepest level.

Okay, now that we are able to generate the items in a Bootstrap friendly format, let’s register some items:

<?php
require_once('autoload.php');
// $menu #1
$main = new Menu;

$main->add('<span class="glyphicon glyphicon-home"></span>', '');
$about = $main->add('about', 'about');
   $about->add('Who we are?', 'who-we-are?');
   $about->add('What we do?', 'what-we-do?');
$main->add('Services', 'services');
$main->add('Portfolio', 'portfolio');
$main->add('Contact', 'contact');

// menu #2
$user = new Menu;

$user->add('login', 'login');
$profile = $user->add('Profile', 'profile');
  $profile->add('Account', 'account')
          ->link->prepend('<span class="glyphicon glyphicon-user"></span> ');
  
  $profile->add('Settings', 'settings')
          ->link->prepend('<span class="glyphicon glyphicon-cog"></span> ');
	
?>

And here’s our boilerplate code:

<nav class="navbar navbar-default" role="navigation">
  <div class="container-fluid">
    <!-- Brand and toggle get grouped for better mobile display -->
    <div class="navbar-header">
      <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
        <span class="sr-only">Toggle navigation</span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
        <span class="icon-bar"></span>
      </button>
      <a class="navbar-brand" href="#">Sitepoint</a>
    </div>

    <!-- Collect the nav links, forms, and other content for toggling -->
    <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
      <ul class="nav navbar-nav">
        <?php echo bootstrapItems($main); ?>
      </ul>
      <form class="navbar-form navbar-left" role="search">
        <div class="form-group">
          <input type="text" class="form-control" placeholder="Search">
        </div>
        <button type="submit" class="btn btn-default">Submit</button>
      </form>
      <ul class="nav navbar-nav navbar-right">
         	<?php echo bootstrapItems($user); ?>
      </ul>
    </div><!-- /.navbar-collapse -->
  </div><!-- /.container-fluid -->
</nav>

Because we have two different menus, we call BootstrapItems two times in our Bootstrap template.

Don’t forget to have jquery and bootstrap CSS and JS files loaded in your page before testing out the result!

Conclusion

We implemented a Menu manager, Items and Links in three class definitions for the sake of flexbility. We also stored a reference to the manager along with each item. This reference allowed us to access the manager from within Item context.

You can use this menu builder in any form you like as long as you use the right methods.

If you’re using Laravel 4, you can get laravel-menu which is implemented based on the methods described in this tutorial while providing more features, otherwise, see the full code of our built Menu Builder: fleximenu.

Happy coding!

 

Script básico de firewall

# Generated by iptables-save v1.4.7 on Fri Jul 22 10:49:57 2016
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [74154352:244251626135]
-A INPUT -s 185.106.120.0/22 -j DROP
-A INPUT -i lo -j ACCEPT
-A INPUT -s 127.0.0.0/8 ! -i lo -j REJECT –reject-with icmp-port-unreachable
-A INPUT -p icmp -m state –state NEW -m icmp –icmp-type 8 -j ACCEPT
-A INPUT -p tcp -m tcp –dport 9091 -m state –state NEW -j ACCEPT
-A INPUT -s 177.82.111.146/32 -p tcp -m tcp –dport 3306 -j ACCEPT
-A INPUT -s 127.0.0.1/32 -p tcp -m tcp –dport 3306 -j ACCEPT
-A INPUT -p tcp -m tcp –dport 3306 -j DROP
-A INPUT -m state –state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -m limit –limit 5/min -j LOG –log-prefix “iptables_INPUT_denied: ” –log-level 7
-A INPUT -j REJECT –reject-with icmp-port-unreachable
-A FORWARD -m limit –limit 5/min -j LOG –log-prefix “iptables_FORWARD_denied: ” –log-level 7
-A FORWARD -j REJECT –reject-with icmp-port-unreachable
COMMIT
# Completed on Fri Jul 22 10:49:57 2016

Limpar todas as regras do IPTABLES

//conteudo abaixo em limpa.sh

#!/bin/sh
echo “Limpando todas as regras e liberando todo o tráfego…”
/sbin/iptables -P INPUT ACCEPT
/sbin/iptables -P FORWARD ACCEPT
/sbin/iptables -P OUTPUT ACCEPT
/sbin/iptables -F
/sbin/iptables -X
/sbin/iptables -t nat -F
/sbin/iptables -t nat -X
/sbin/iptables -t mangle -F
/sbin/iptables -t mangle -X
/sbin/iptables -L -n