Bom, eu cortei o vídeo em 3 partes por causa do you tube, mas os próximo vídeos terã 15 minutos e abordarei somente um tema.

Estarei postando também alguns artigos e tutoriais em forma de texto.

Quando eu fizer algum vídeo que tenha exemplos, colocarei o download dos demos no final do post. Espero que gostem e até o próximo post!

Parte 01

Parte 02

Parte 03

… até mais pessoal

Estarei falando sobre o PHP (OO), framwork ZEND, a biblioteca  jquery, css, xhtml, html, xml, e outros assuntos relativos ao desenvolvimento web.

Sugestões sobre assuntos, mandem por comentários ou e-mail.

A Web semântica interliga significados de palavras e, neste âmbito, tem como finalidade conseguir atribuir um significado (sentido) aos conteúdos publicados na Internet de modo que seja perceptível tanto pelo humano como pelo computador.

O objectivo principal da Web semântica não é, pelo menos para já, treinar as máquinas para que se comportem como pessoas, mas sim desenvolver tecnologias e linguagens que tornem a informação legível para as máquinas. A finalidade passa pelo desenvolvimento de um modelo tecnológico que permita a partilha global de conhecimento assistido por máquinas (W3C 2001). A integração das linguagens ou tecnologias eXtensible Markup Language (XML), Resource Description Framework (RDF), arquiteturas de metadados, ontologias, agentes computacionais, entre outras, favorecerá o aparecimento de serviços Web que garantam a interoperabilidade e cooperação.

Bem, procurando pela internet, achei isso:

e mais isso:

Etapa 1.

A primeira pergunta é por isso que precisamos se nós temos toda a função em PHP como nativa. Há mais argumentos:

* Você pode facilmente reutilizar o script em todo o seu desenvolvimento.
* Você pode alterar a base de dados sem alterar todo o seu script. Você precisará editar apenas a classe.
* Você pode fazer optimização e simplificação mais fácil.
* Você pode centralizar o acesso e manipulação de erro DB.
* Você pode fazer a depuração mais fácil.
* Você pode fácilmente implementar estatísticas em tempo de consulta e contadores de consulta.

Agora vamos resumir o tipo de função que precisamos:

* Criar uma conexão com o banco
* Execução de queries SQL
* Recebe o número de linhas selecionadas se possível
* Recebe o número de linhas modificadas, se possível
* Receber o id(auto increment) mais recente, se foi possível inserir
* Coloque um resultado da consulta em um array normal
* Mensagem de erro e / ou identificação(code), se necessário
* Obter o tempo total gasto no banco de dados
* Recebe o número de consultas realizadas

Etapa 2.

Antes que possamos iniciar a implementação das funções que precisamos de todas as variáveis de classe comum usado que armazena informações importantes.
Estes são:

* Um identificador de conexão para armazenar o link de conexão real.
* Um conjunto de resultados para armazenar resultados da consulta.
* Uma mensagem de erro e erro id para armazenar informações de erro.
* Um contador para contar as consultas executadas.
* Um contador de tempo para armazenar os tempos de consulta total.

Assim, a classe base fica assim:
MysqlAbs.class.php

 <? php

classe MysqlAbs (

 var $conectado   = ''; // link de conexao
 var $queryCounter = 0; // contador de query
 var $tempoTotal    = 0;     // contador de tempo
 var $errorCode    = 0; //codigo de erro
 var $errorMsg     = ''; // mensagem de erro
 var $resultSet    = '';

 // conexao padrao quando nao for setada
 var $servidor="localhost"; // host
 var $usuario="root"; // user
 var $senha=""; //senha
 var $banco="test"; //banco)
?>

Etapa 3.

Agora podemos implementar as funções. Vamos começar com o mais importante. Conectando-se ao banco de dados. O construtor da classe será responsável por construir a conexão com a base de dados. Portanto, se você criar um objeto de banco de dados a partir desta classe imediatamente tera uma conexão válida também.

Assim, o construtor tem os seguintes parâmetros:
* Hostname
* Usuário
* Senha
* Nome do banco de dados

Na função tentamos conectar ao servidor de banco de dados e se conseguirmos,  tentamos selecionar o banco de dados. Em caso de erro temos que definir a mensagem de erro e o codigo de erro e retornar como falso.

O construtor da classe é o seguinte:

<? php
 function __construct() {
 $this -> conexao($this->servidor,$this->usuario,$this->senha,$this->banco);
}
function conexao($host, $user, $pass, $db){
 $startTime = $this->getMicroTime();

 // faz a conexao com o servidor
 if (!$this->conectado = @mysql_connect($host,$user,$pass,true)){
 $this->errorCode = mysql_errno();
 $this->errorMsg  = mysql_error();
 return false;

 }

 // faz a selecao do banco
 if (!@mysql_select_db($db,$this->conectado)){
 $this->errorCode = mysql_errno();
 $this->errorMsg  = mysql_error();
 @mysql_close($this->conectado);
 return false;
 }

 $this->tempoTotal += $this->getMicroTime() - $startTime;

 return true;
 }

?>

Acima eu crio o construct que instanciará a conexao, assim como padrao fica a conexão com os dados que estao dentro da classe, se for instanciado e passado os parametros ele criara a conexao. Caso contrário ele retornará falso com uma mensagem de erro.

Etapa 4.

Como próximo passo vamos implementar a função de execução da consulta. Nesta função podemos medir o tempo de execução (veja os detalhes mais tarde), aumentando o contador de consulta e, claro, de executar a consulta em si. Se ocorrer um erro, definir a mensagem de erro e de codigo de erro  e retorna como falso. Se tudo estiver  funcionando voltamos bem com o conjunto de resultados.

O código é o seguinte:

<? php
 function executeQuery($sql){

 $startTime = $this->getMicroTime();

 ++$this->queryCounter;

 if(!$this->resultSet = @mysql_query($sql,$this->conectado)){
 $this->errorCode = mysql_errno();
 $this->errorMsg  = mysql_error();
 $this->totalTime = $this->getMicroTime() - $startTime;
 return false;
 }
 $this->totalTime += $this->getMicroTime() - $startTime;

 return $this->resultSet;
 }
?>

Se a consulta contém um Insert, Update ou o comando DELETE, pode ser importante para saber quantos registros foram afetados por esta consulta. Para obtê-lo vamos implementar uma função, como segue:

<? php
 function getAffectedRows()
 {
 return @mysql_affected_rows($this->conectado);
 }
?>

No caso de um select,  o número de registros poderia ser interessante. Para obtê-lo, temos uma função semelhante:

<? php
 function getSelectedRows()
 {
 return @mysql_num_rows($this->resultSet);
 }
?>

Neste tópico, temos uma última questão importante. Em caso de Inserção talvez nós queremos saber o id que foi criado. Para obter essa informação após o registro ser inserido, podemos usar o seguinte código:

<? php
 function getInsertId()
{
 return @mysql_insert_id($this->conectado);
 }
?>

Etapa 5.

Agora vamos criar alguma outra função útil para tornar a nossa classe melhor.
Em caso de select, por vezes, seria bom ter um array associativo em vez do MySQL result set. Então, vamos implementar uma função que retorna a essa matriz gerada a partir de um conjunto de resultados reais.
O código fica assim:

<? php
function loadResult()
 {
 $array = array();
 while ($row = mysql_fetch_object( $this->resultSet )) {
 $array[] = $row;
 }
 mysql_free_result( $this->resultSet );

 return $array;
 }

?>

Como a nossa função não enviar mensagens de erro de volta para o chamador apenas define as variáveis de erro dentro da classe por isso precisamos de função para obter essa informação. Estas são funções getter simples como o seguinte:

<? php
 function getErroCode(){
 return $this->errorCode;
 }

 function getErroMsg(){
 return $this->errorMsg;
 }
?>

Etapa 6.

Como passo final é preciso implementar uma função para obter tempos de consulta. Para fazê-lo, precisamos de uma função que retorna o tempo atual em milisegundos.
Chamando essa função no início e no final das chamadas de funções de conexao, query ou outras do tipo, poderemos calcular o tempo total gasto no db.
Além deste vamos implementar outras 2 funções getter para obter o número de consultas realizadas eo tempo total da consulta em um formato util.

Assim, nossas funções:

<? php
 function getTempo(){
 return round($this->tempoTotal,6);
 }

 function getSqlCount(){
 return $this->queryCounter;
 }

 function getMicroTime() {
 list($usec, $sec) = explode(" ",microtime());
 return ((float)$usec + (float)$sec);
 }
?>

Bom é isso, no próximo eu mostrarei como utilizar esta classe.. até breve.

Estes dias estava com dificuldade em ler um XML, de tanto procurar na web encontrei este blog:

http://www.vedovelli.com.br/?p=83

Resolvi compartilhar para ajudar quem tem ou terá o mesmo problema que eu tive. Modifiquei certas coisas, comentei e postei aqui, espero que tenham facilidade em entender o Post!, qualquer duvida comentem.

<?xml version="1.0" encoding="UTF-8"?>
<root>
<bandas>
<nome>Asian Dub Foundation</nome>
<nome>REM</nome>
<nome>Everything But The Girl</nome>
</bandas>
</root>

O xml é o mesmo do exemplo do blog que eu copiei.

Agora temos o php que lerá o XML acima

<?php
$xml = simplexml_load_file("arquivo.xml"); // Pode ser http://www.algumdominio.com/services/arquivo.xml

for($i=0; $i < count($xml->bandas->nome); $i++) {
 echo $xml->bandas->nome[$i]."<br />";
}
?>

Para outro exemplo tenho o XML abaixo

<?xml version="1.0" encoding="UTF-8"?>
<root>
<bandas>
Gringas
<nome>Asian Dub Foundation</nome>
<nome>REM</nome>
<nome>Everything But The Girl</nome>
</bandas>

<bandas>
Da nossa Terra
<nome>Detonautas</nome>
<nome>CPM 22</nome>
<nome>Skank</nome>
</bandas>
</root>

E o php que faz a leitura

<?php
// lê o arquivo xml
$xml = simplexml_load_file("arquivo2.xml");

// le todos os filhos pricipais - no caso "bandas"
foreach($xml->children() as $child){
 // imprime o texto interno
 echo "<br /><br /><strong>".$child.":</strong> <br />";

 // le todos os of filhos dos filhos pricipais - no caso "nome"
 foreach($child as $asd){
 // imprime o texto interno
 echo "" . $asd . "<br />";
 }
}

// foreach - enquanto tem dados ele lê
// pelo menos é isso que eu entendo
?>

Neste segundo exemplo eu leio o XML, e para cada filho leio seus filhos. Assim tenho o filho “bandas” e seus filhos “nome”.

Os exemplos podem ser vistos aqui.

Em breve exemplo usarei o envio de formulário, deixarei a validação do mesmo para um post posterior.

Primeiramente acesse este link http://docs.jquery.com/Downloading_jQuery, e faça o download da versão mais recente da JQuery.

Seguindo a estrutura html básica

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Ajax Post - Erick Alves</title>
<script src="js/jquery-1.3.2.min.js" type="text/javascript" language="javascript"></script>

</head>

<body>
<form action="#" method="post">
<label>Nome: <input type="text" name="nome" id="nome" /></label>
<label>Email: <input type="text" name="email" id="email" /></label>
<label>Telefone: <input type="text" name="telefone" id="telefone" /></label>
<input type="button" value="Enviar" id="enviar" />
</form>
<div id="resposta"></div>
</body>
</html>

Neste html eu criei um formulario com os campos, nome, email e telefone,  respectivamente cada um com seu id, para utilizarmos eles no jQuery.

Entres as tags <head></head> eu inseri o jQuery

<script src="js/jquery-1.3.2.min.js" type="text/javascript" language="javascript"></script>

Depois disso criaremos uma página chamada de enviar.php com a seguinte estrutura

<?php
// recebo os campos via $_POST[''];
$nome = $_POST['nome'];
$email = $_POST['email'];
$telefone = $_POST['telefone'];

// verifico se estão preenchidos
if (!($nome) || !($email) || !($telefone)){
     echo 'Preencha todos os campos!';
     exit();
}
//Abrindo Conexao com o banco de dados
$conexao = mysql_pconnect("localhost","usuario","senha") or die (mysql_error());
$banco = mysql_select_db("bancodedados");

//Utilizando o  mysql_real_escape_string voce se protege o seu código contra SQL Injection.
$nome = mysql_real_escape_string($nome);
$email = mysql_real_escape_string($email);
$telefone = mysql_real_escape_string($telefone);

$insert = mysql_query("insert into contatos (nome,email,telefone) values ('{$nome}','{$email}','{$telefone}')");
mysql_close($conexao);
if($insert) {
     echo 'Cadastro Realizado!';
}else {
     echo 'Erro ao Cadastrar!';
}
?>

O exemplo acima está auto comentado e de fácil entendimento.

E agora? O formulario não vai funcionar pois não estamos setando nenhum action nele. Isso é importante para o funcionamento dele via jQuery.

Utilizaremos agora a função click do jQuery, instanciando o elemento de id “enviar“, no caso do formulario html o botão de envio.

Receberemos os valores dos campos de id:

• nome
• email
• telefone

Feito isso, teremos a função post do jQuery, requisitando dados no envia.php e passando como paramentro nossos campos.

Instanciamos o elemento de id “resposta” para receber o retorno do nosso ajax.

Tudo isso é feito utilizando o script jQuery abaixo

<script type="text/javascript">
$(document).ready(function() {
    $("#enviar").click(function() {
       var nome = $("#nome");
       var nomePost = nome.val();
       var email = $("#email");
       var emailPost = email.val();
       var telefone = $("#telefone");
       var telefonePost = telefone.val();
       $.post("enviar.php", {nome: nomePost, email: emailPost, telefone: telefonePost},
       function(data){
          $("#resposta").html(data);
       }
       , "html");
     });
});
</script>

Que deve ser inserido entre as tags head do seu html.

Fim…

Temos também no jQuery outros modos de enviar requisições ajax, como a própria funçao $.ajax().

Mas deixarei isso para outro post, assim como as validações.

Bem isso é tudo pessoal.

Neste post vou mostrar uma introdução ao Jquery, motivos para utiliza-lo no desenvolvimento de um web site.

Vantagens:

• Compatibilidade com qualquer navegador;
• Seu peso é bem leve ficando em torno de 20kb(comprimido);
• Otimização de código, você evita de programar linhas e linhas de código;
• Você consegue acessar a qualquer elemento ou combinações de elementos;
• Possui diversos efeitos visuais para deixar seu site mais atraente.

Introdução

Primeiramente acesse este link http://docs.jquery.com/Downloading_jQuery, e faça o download da versão mais recente da JQuery. De prefencia baixe a versão comprimida.

Após ter efetuado o download bastar inserir o jquery entre os heads do seu html

<script type="text/javascript" language
="javascript" src="javascript/jquery.js"></script>

Utilizando

O uso do jQuery é bem simples, digamos que você queira selecionar todas as tgs ‘div’.

Em javascript

document.getElementsByTagName("div");

Em jQuery:

("div");

Seguindo o exemplo acima já podemos ter uma noção da simplicidade do uso do jQuery. Agora supomos que vc queira selecionar não todas as divs, mas outro elemento pelo id ou pela classe.

// pela id conteudo
("#conteudo");

// pela classe link
(".link");

//um link com a classe titulo
("a.titulo");

//selecionando todas as div com a classe menu que estão dentro da div conteudo
("#conteudo div.menu");
//ou
("div.menu", "#conteudo");

A estrutura segue este padrão bem simples. Sem muita complicação.

Bom agora vejamos como utilizar efeitos no jQuery.

// escondendo um elemento
("#id_do_elemento").hide()

// mostrando o elemento
("#id_do_elemento").show()

No exemplo acima temos
(“#id_do_elemento”) = refencia ao elemento
hide(“slow”) = efeito

O jQuery conta também com efeitos do tipo fadeIn, fadeOut e fadeTo

("p").fadeIn("slow");
("p").fadeOut("slow");
("p").fadeTo("slow");

Eventos

Agora queremos um elemento que ao clicarmos nele dispara um evento em outro elemento.

Estrutura html

<a href="#" class="mostra">mostrar div</a>

<div id="recebe" style="display:none;">estou mostrando esta div</div>

Estrutura jQuery

$(document).ready(function(){
                $("a.mostra").click(function(){
                         $("#recebe").show();
                 });
});

Exemplo:
mostrar div

O que foi feito é bem simples, pegamos a tag de link “a” com a classe “mostra” e adicionamos uma acão ao ser clicado “.click(function(){ }) ;”, dentro da função instanciamos o elemento de id “recebe“, adicionando o efeito de show();

O jQuery é bem dinamico e ainda possibilita a manipulação de objetos DOM, Ajax, validação de formulário e muitos outros efeitos.

Por hoje é tudo pessoal, logo estarei postando aqui mais funcionalidades do jQuery.

Bem, para quem o mesmo problema que eu tive, veja a abaixo a solução.

Sigamos a estrutura a seguir dentro do body.

<body>
<div id="geral">
<div id="corpo">
conteudo
</div>
</div>
</body>

E dentro do seu style ou se preferir colocar dentro de um .css o código a seguir

body{
 background-color:#efefef; /*um fundo para visualizar a div*/
 margin:0px;
 padding:0px;
 text-align:center; /* bug do IE 6*/

}
#geral{
 margin:0 auto;
 width:900px;
 background-color:#FFF; /*um fundo para visualizar a div*/
 text-align:left;
}
#corpo{
 padding:10px;
}

Veja o exemplo aqui

Em termos leigos, fucei e fucei na Internet até encontra o site do João Eriberto Mota Filho, aonde aprendi muito sobre as regras de controle de tráfego utilizando o tc, htb e iptables, então resolvi compartilhar com quem tambêm tem a necessidade de efectuar este controle.

Muitas pessoas confundem controle de tráfego com controle de banda.

• Banda (ou bandwidth):  é a diferença entre os limites superior e inferior de uma freqüência, geralmente medida em hertz.
• Tráfego:  quantidade de informações digitais transmitidas, geralmente medida em bits por segundo (b/s).

Assim, ao controlar um tráfego de rede estaremos realizando um controle de tráfego e não de banda, como muitos dizem. Para alterar as propriedades de uma banda, teremos que fazer alterações físicas no meio.

Agora imagine uma rede que possua Internet, com um link de 2 Mb/s, e 50 máquinas. Exemplos atuais: prédios, pequenas empresas, lan houses, faculdade (essa vai para o Biguá),  etc. Imagine ainda que nessa rede possa ser utilizado qualquer tipo de programa de acesso à Internet.

Numa rede liberal, programas como o EMule ou o Kazaa poderão causar um enorme congestionamento. Um único EMule instalado em um computador da rede poderá abrir dezenas de conexões simultâneas. Com isso, caso algum outro usuário, em outro computador, deseje visitar o GMail, por exemplo, teremos uma máquina, estabelecendo uma conexão, lutando contra outro computador com 60 conexões (apenas um exemplo). Teremos, em outras palavras, 01 contra 60. É óbvio que haverá uma grande desvantagem para um dos dois. Isso ocorre porque, da forma como o Kernel Linux trabalha, normalmente, os pacotes são enfileirados em um buffer e saem na mesma ordem em que chegaram (FIFO, para os mais experientes, o primeiro que entra é o primeiro que sai). Aumentar o link, ao contrário do que muitos desinformados pensam, não resolveria o caso, pois só estaríamos dando mais “poder de fogo” ao usuário do EMule e continuaríamos sendo o 60º da fila. O que fazer então?

• Bloquear o EMule, tornando-se um administrador radical e forçando o usuário de tal programa a achar uma forma de burlar o controle (sempre há uma forma de fazer isso). Ainda, o EMule foi bloqueado mas outros programas similares não. Existem centenas deles.
• Controlar o tráfego da rede, fazendo com que haja um equilíbrio ou uma prioridade na navegação. Esta parece ser a forma mais sensata

Observe as seguintes idéias:

• Em tráfego de rede estaremos submetidos à base decimal e não à binária, como em processamento, armazenamento e memória. Assim, 1 KByte por segundo será igual a 1000 bytes por segundo.
• A abreviatura de byte é B.
• A abreviatura de bit é b.
• 1 B = 8 b (um byte é composto por 8 bits).

Assim, 250 Kb/s são iguais a 31,25 KB/s que são iguais a 31250 B/s.

Agora cheguei em uma parte interessante: Como funciona o HTB.

O HTB funciona de forma hierárquica e, como todas as outras disciplinas, controla os pacotes que saem de uma determinada placa de rede. Isso se deve ao fato de que, quando um pacote chega a uma máquina, ele não pode ficar parado no cabo de rede ou na onda de rádio (wireless) esperando para entrar na placa. O pacote entra e é armazenado no buffer. Assim, só resta controlar a sua saída do buffer para a rede.

Imagine um servidor Linux aonde temos duas placas de rede:

• eth0: ligada a rede interna
• eth1: ligada a internet

A interface eth0 irá controlar todo o download da Internet e a interface eth1 todo o upload.

No que tange à hierarquia, o HTB possui um elemento principal conhecido como root, que receberá a designação numérica 1:0 ou, simplesmente, 1:. O root possui um subordinado imediato, que controla o tráfego máximo total possível. Esse subordinado é uma classe e receberá a designação 1:1.

Os elementos superiores a cada classe são conhecidos como pais. A indicação para isso é parent.

A seguir um exemplo de configuração do root e do parent de controle total de tráfego, para a interface eth0, com o comando tc:

tc qdisc add dev eth0 root handle 1:0 htb default 40
tc class add dev eth0 parent 1:0 classid 1:1 htb rate 100mbit

A primeira linha estabelece o root, para a interface eth0, com a designação 1:0, usando a disciplina HTB. A palavra qdisc é a abreviatura de Queue discipline ou disciplina de enfileiramento. Em resumo, refere-se à disciplina de controle de tráfego. A primeira linha também estabelece que a classe default será a 1:40.

A classe default será utilizada para receber pacotes que não foram designados para trafegar em qualquer outra classe.

A segunda linha estabelece que a classe 1:0 será parent (pai) da 1:1. Esta classe estabelece que a interface de rede eth0 funcionará a 100 Mb/s.

Veja agora uma configuração do HTB já com algumas classes (dentro de um script em shell bash):

#!/bin/bash

tc qdisc del dev eth0 root

tc qdisc add dev eth0 root handle 1:0 htb default 40
tc class add dev eth0 parent 1:0 classid 1:1 htb rate 100mbit

tc class add dev eth0 parent 1:1 classid 1:10 htb rate 100kbit  ceil 300kbit  prio 0   # DNS / ACK / SYN / FIN
tc class add dev eth0 parent 1:1 classid 1:20 htb rate 500kbit  ceil 800kbit  prio 1   # E-mail
tc class add dev eth0 parent 1:1 classid 1:30 htb rate 1200kbit ceil 1600kbit prio 2   # HTTP / HTTPS
tc class add dev eth0 parent 1:1 classid 1:40 htb rate 300kbit  ceil 500kbit  prio 3   # Geral

A primeira linha remove qualquer pré-configuração existente. As duas linhas seguintes já foram analisadas. As próximas linhas são as classes que irão controlar o tráfego.

A classe 1:10 é filha da classe 1:1. Ela permitirá um tráfego de 100 Kb/s. Caso as outras classes estejam livres, sem tráfego, esta classe poderá emprestar um pouco do link que sobra nas outras, podendo chegar a 300 Kb/s. Esta classe tem prioridade 0, ou seja, todas as outras irão parar para o seu tráfego passar (caso isso seja necessário). No fim da linha há um comentário, que não é obrigatório. Por intermédio desse comentário, entendemos que a classe 1:10 será utilizada para tráfego DNS e para alguns pacotes com algumas flags TCP. A análise das demais classes segue o mesmo raciocínio. Apenas relembrando, a classe 1:40 é a classe default e, tudo que não for enviado para as outras classes terminará passando por ela.

A seguir, uma imagem que resume toda a situação explanada até aqui:

É interessante fazer uma configuração para a interface eth1 para controlar o upload. A configuração para a eth1 segue os mesmos princípios da eth0. Exemplo:

#!/bin/bash

tc qdisc del dev eth1 root

tc qdisc add dev eth1 root handle 1:0 htb default 40
tc class add dev eth1 parent 1:0 classid 1:1 htb rate 100mbit

tc class add dev eth1 parent 1:1 classid 1:10 htb rate 100kbit ceil 300kbit prio 0   # DNS / ACK / SYN / FIN
tc class add dev eth1 parent 1:1 classid 1:20 htb rate 500kbit ceil 500kbit prio 1   # E-mail
tc class add dev eth1 parent 1:1 classid 1:30 htb rate 300kbit ceil 500kbit prio 2   # FTP
tc class add dev eth1 parent 1:1 classid 1:40 htb rate 300kbit ceil 500kbit prio 3   # Geral

Na classe 1:20, a opção ceil 500kbit poderia ter sido omitida, uma vez que tal ceil possui o mesmo valor de rate.

A instalação do comando tc e da disciplina HTB no Debian GNU/Linux

Para instalar o tc e o HTB no Debian, execute:

# apt-get install iproute

A associação do HTB com o Iptables

A divisão do tráfego pelas classes poderá ser feito com o auxílio do Iptables, utilizando a tabela mangle e o alvo CLASSIFY. A seguir, um exemplo de script de configuração do Iptables:

#!/bin/bash

PATH=/bin:/sbin:/usr/bin:/usr/sbin

iptables -t mangle -F

# portas e-mail (entrada e saida)

iptables -t mangle -A FORWARD -p tcp -m multiport --ports 25,110,995 -j CLASSIFY --set-class 1:20

# trafego HTTP entrando

iptables -t mangle -A FORWARD -o eth0 -p tcp --sport 80 -j CLASSIFY --set-class 1:30

# trafego FTP saindo (upload)

iptables -t mangle -A FORWARD -o eth1 -p tcp --dport 20 -j CLASSIFY --set-class 1:30

# DNS e ACK/SYN/FIN (pacotes com até 60 bytes)

iptables -t mangle -A FORWARD -p udp -m multiport --ports 53 -j CLASSIFY --set-class 1:10  # DNS
iptables -t mangle -A FORWARD -m length --length 0:60 -j CLASSIFY --set-class 1:10         # Flags TCP

Note que nas classes 1:30, em virtude das opções -o eth0 e -o eth1, a interface eth0 será acionada somente para o tráfego HTTP que entra e a interface eth1 somente para o tráfego FTP que sai (porta 20 – dados).

A ordem das regras

Diferentemente das tabelas filter e nat, a tabela mangle lê todas as regras, até o final, mesmo que uma delas case com a situação do pacote em tráfego. Assim, deveremos colocar casos mais específicos como últimas regras.

Observe o exemplo a seguir:

# iptables -t mangle -A FORWARD -d 10.0.0.1 -p tcp --sport 110 -j CLASSIFY --set-class 1:65
# iptables -t mangle -A FORWARD -d 10.0.0.0/8 -p tcp --sport 110 -j CLASSIFY --set-class 1:70

A idéia das regras anteriores foi limitar a leitura de e-mails (protocolo POP3). A máquina 10.0.0.1 vai utilizar a classe 1:65, enquanto que o resto da rede 10.0.0.0 vai ser enquadrada na classe 1:70. No entanto, na prática, isso não irá acontecer, uma vez que a tabela mangle lê todas as regras existentes até o final. Assim, um pacote oriundo da máquina 10.0.0.1 será enquadrado pela primeira regra e, em seguida, pela segunda. Então, valerá a última situação. Ou seja, a ordem correta das regras deverá ser a seguinte:

# iptables -t mangle -A FORWARD -d 10.0.0.0/8 -p tcp --sport 110 -j CLASSIFY --set-class 1:70
# iptables -t mangle -A FORWARD -d 10.0.0.1 -p tcp --sport 110 -j CLASSIFY --set-class 1:65

Tráfego local

Como já foi dito, o controle de tráfego deverá ser feito no momento da saída do pacote pela placa de rede. Assim, caso você tenha que controlar o tráfego gerado pela máquina que contém o HTB, deverá ser utilizada a chain OUTPUT do Iptables. Isso será útil se, por exemplo, você quiser liberar totalmente o acesso à máquina de controle. Se você não fizer isso, um ssh para tal máquina, por exemplo, será impraticável. A seguir, um exemplo de liberação do tráfego:

# tc class add dev eth0 parent 1:1 classid 1:90 htb rate 100mbit prio 0
# iptables -t mangle -A OUTPUT -j CLASSIFY --set-class 1:90

Verificando as qdiscs e as classes existentes

Para verificar as qdiscs e as classes configuradas na eth0, execute:

# tc qdisc show dev eth0
# tc class show dev eth0

Caso deseje ver também detalhes e estatísticas, acresça as chaves -d e -s, da seguinte forma:

# tc -d -s qdisc show dev eth0
# tc -d -s class show dev eth0

O módulo multiport do Iptables

O módulo multiport do Iptables é um excelente elemento para ser utilizado em controle de tráfego, uma vez que é muito flexível. Observe as regras a seguir:

# iptables -t mangle -A FORWARD -p tcp --sport 110 -j CLASSIFY --set-class 1:78
# iptables -t mangle -A FORWARD -p tcp --sport 995 -j CLASSIFY --set-class 1:78

Essas regras poderiam ser substituídas por:

# iptables -t mangle -A FORWARD -p tcp -m multiport --sport 110,995 -j CLASSIFY --set-class 1:78

Ainda, observe:

# iptables -t mangle -A FORWARD -p tcp --sport 110 -j CLASSIFY --set-class 1:78
# iptables -t mangle -A FORWARD -p tcp --sport 995 -j CLASSIFY --set-class 1:78

# iptables -t mangle -A FORWARD -p tcp --dport 25 -j CLASSIFY --set-class 1:78
# iptables -t mangle -A FORWARD -p tcp --dport 465 -j CLASSIFY --set-class 1:78

Essas regras poderiam ser substituídas por:

# iptables -t mangle -A FORWARD -p tcp -m multiport --port 25,110,465,995 -j CLASSIFY --set-class 1:78

Outros módulos poderão ser úteis. Para aprender mais sobre eles, utilize o comando:

# man iptables

As somas das velocidades das classes

As somas das velocidades das classes não necessariamente precisarão ser menores do que a velocidade máxima do link. Apenas como exemplo, admita um link Internet de 1 Mb/s. Você poderá trabalhar com as seguintes classes e prioridades:

Observando a figura anterior, podemos notar que a soma das velocidades é 1150 Kb/s, enquanto o link total é 1000 Kb/s. No entanto, como trabalhamos com prioridades, haverá uma tendência das classes com menos prioridade diminuírem as suas velocidades, proporcionalmente, quando o link estiver saturado, para que as classes com mais prioridade possam trafegar. Entretanto, em virtude das velocidades utilizadas, em caso de saturação do link, nenhuma das classes deverá parar.

Observe que não há uma necessidade de seguir uma ordem crescente numérica regular para numerar as classes e as prioridades. O mais importante é fazer a correta ligação com os pais.

Pense nisto…

Observe a figura a seguir e deixe a sua imaginação fluir…

Agora, imagine a possibilidade de ramificar a classe 1:50 em mais duas ou três classes…

fonte:  João Eriberto Mota Filho

1- Tenha claro o que procura
Estar focado no que se busca é básico para que não se perca tempo. Mas se existe algo que inclina à divagação e à dispersão é a busca na Internet. Quando estamos procurando, às vezes encontramos coisas que não eram exatamente nosso objetivo, mas que se tornam interessantes. Então, vamos olhar, e acabamos perdendo o caminho. Portanto, ao iniciar uma busca, tenha um objetivo bem definido em mente. Por exemplo, saber “qual o nome dos sete anões da Branca de Neve em espanhol” – e evite perder tempo averiguando quem dubla cada um dos personagens, o ano do filme da Disney, quantas vezes foi exibido, e assim por diante.

2- Escolha a ferramenta adequada
“Ora, o Google”, dirão alguns. Mas ainda que este seja o buscador mais popular, a informação flui por diferentes caminhos. Não se restrinja ao site campeão: outros meios podem ser fóruns, blogs, sites especializados ou até mesmo seus contatos no messenger. Às vezes, o que se procura está a um contato de distância. Preste atenção também a outros mecanismos de buscas – sim, eles existem.

3- Aprenda a usar a ferramenta
Ao escolher um buscador, antes de mais nada vale a pensa investir um pouco de tempo para saber exatamente como ele funciona. Se é melhor realizar a busca usando os termos entre aspas, se usa os operadores lógicos “and”, “or” e outros, ou se realiza buscas contextuais em páginas concretas. Todo o tempo gasto em conhecer a ferramenta é tempo que será economizado ao conseguir utilizá-la com objetividade.

4- Seja claro e objetivo
Ainda que os mecanismos de buscas vão sendo otimizados para entender a maneira de pensar humana, os humanos também podem conhecer a maneira de raciocinar de uma ferramenta de busca. Por exemplo, para fazer uma busca de várias palavras, é conveniente pensar não apenas em como se procura mas também em como o programa que gerencia as buscas vai entender o pedido que se faz. Por exemplo, em vez de procurar por “amor e poesia”, frase que tem um “e” que muitas vezes é ignorado pelos buscadores, é melhor buscar “poesia amor” – mais facilmente o programa entenderá que são duas palavras-chave a considerar em seus parâmetros de busca.

5 – Aprenda a diferenciar à primeira vista
Ao fazer uma busca, é bom conseguir determinar de cara se os resultados têm algo a ver o que se quer encontrar. Basta olhar as primeiras palavras de cada resultado para saber se foi encontrada informação útil ou simplesmente sites que pouco têm a ver com o que se precisa encontrar. Perca alguns segundos analisando as primeiras linhas dos resultados. Você saberá se está na pista certa.

6- Use inglês, dicionários e tradutores
Outras línguas, como espanhol ou português, podem até estar ganhando mais espaço na Internet, mas a realidade é que a imensa maioria das páginas está – ou oferece versão – em inglês. Portanto, se você não encontra em português o que procura, experimente traduzir as palavras-chave para o inglês e fazer nova busca. Se precisar, utilize dicionários ou mesmo os tradutores online para investigar páginas que pareçam interessantes.

7- Aprenda a buscar indiretamente
A busca indireta dá resultados ótimos quando parece ser impossível encontrar aquilo que se busca. Trata-se de não atacar diretamente o tema que procuramos, mas buscar algo relacionado com ele. Por exemplo, procurar a letra de uma canção de Elvis Presley da qual não se lembra o nome. Se não se encontra nada a partir de “Elvis Presley”, pode-se experimentar usar um pedaço da letra do qual se recorde (como “kiss me my darling”). Entre os primeros resultados, certamente estará a letra de “It’s now or never”. Isso é aplicável a uma grande variedade de temas, e é especialmente útil quando o tema principal da busca é muito amplo ou quando, por exemplo, buscamos o nome de uma pessoa, já que pode haver muito mais gente com tal nome do que se imagina.

8- Imagens
A busca de imagens é especialmente complicada, e para conseguir os melhores resultados, além de usar dicas anteriores (busca indireta, tradução para outras línguas), não use apenas a busca de imagens do Google, por exemplo. Procure também por sites que possam conter as imagens que você quer, e aproveite outros buscadores – inclusive específicos para imagens.

9- A Wikipedia é amiga
Se a procura é por um termo popular, é quase certo que já exista na wikipedia. A enciclopédia global online colaborativa tem informação de qualidade. Não se perde muito tempo em consultá-la, mas pode-se economizar tempo ao encontrar lá o que se procura e, muitas vezes, outras referências sobre o assunto permitem que se tenha mais fontes de informação.

10- Experiência é a princial aliada
Na busca via Internet a experiência não é um grau, são 360. À medida que fizer buscas, você aprenderá a discriminar melhor, vai adicionar aos seus sites favoritos outros buscadores especializados, que funcionem melhor para determinados assuntos, e aprenderá também a pensar mais como uma ferramenta de busca, porque as entenderá melhor. Ou seja: busque e aprenda com as buscas que faz. Em pouco tempo você se tornará uma ferramenta indispensável para outras pessoas que não vão precisar de um buscador: elas terão você.

Fonte: www.terra.com.br