One place for hosting & domains

      Imagens

      Como Usar o Tipo de Dados MySQL BLOB para Armazenar Imagens com PHP no Ubuntu 18.04


      O autor selecionou Girls Who Code para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Um Binary Large Object (BLOB) é um tipo de dados MySQL que pode armazenar dados binários como imagens, multimedia e arquivos PDF.

      Ao criar aplicações que requerem um banco de dados fortemente acoplado onde imagens devem estar sincronizadas com dados relacionados (por exemplo, um portal de funcionários, um banco de dados de estudantes, ou uma aplicação financeira), você pode achar que é conveniente armazenar imagens como fotos de passaporte e assinaturas de alunos em um banco de dados MySQL, juntamente com outras informações relacionadas.

      É aqui que o tipo de dados MySQL BLOB entra. Esta abordagem de programação elimina a necessidade de criar um sistema de arquivos separado para armazenar imagens. O esquema também centraliza o banco de dados, tornando-o mais portátil e seguro porque os dados estão isolados do sistema de arquivos. A criação de backups também é mais simples, pois você pode criar um único arquivo de dump do MySQL que contém todos os seus dados.

      A recuperação de dados é mais rápida e, ao criar registros, você pode garantir que as regras de validação de dados e a integridade referencial sejam mantidas especialmente ao utilizar as transações do MySQL.

      Neste tutorial, você usará o tipo de dados MySQL BLOB para armazenar imagens com PHP no Ubuntu 18.04.

      Pré-requisitos

      Para seguir com este guia, você precisará do seguinte:

      Passo 1 — Criando um Banco de Dados

      Você começará criando um banco de dados de exemplo para seu projeto. Para fazer isso, faça um SSH em seu servidor e, em seguida, execute o seguinte comando para fazer login no seu servidor MySQL como root:

      Digite a senha do root do seu banco de dados MySQL e clique em ENTER para continuar.

      Em seguida, execute o seguinte comando para criar um banco de dados. Neste tutorial, iremos nomeá-lo como test_company:

      • CREATE DATABASE test_company;

      Assim que o banco de dados for criado, você verá a seguinte saída:

      Output

      Query OK, 1 row affected (0.01 sec)

      Em seguida, crie uma conta test_user no servidor MySQL e lembre-se de substituir PASSWORD por uma senha forte:

      • CREATE USER 'test_user'@'localhost' IDENTIFIED BY 'PASSWORD';

      Você verá o seguinte resultado:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Para conceder ao test_user privilégios completos no banco de dados test_company, execute:

      • GRANT ALL PRIVILEGES ON test_company.* TO 'test_user'@'localhost';

      Certifique-se de obter a seguinte saída:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Finalmente, libere a tabela de privilégios para que o MySQL recarregue as permissões:

      Certifique-se de ver a seguinte saída:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Agora que o banco de dados test_company e o test_user estão prontos, você prosseguirá com a criação de uma tabela products para armazenar produtos de exemplo. Você usará esta tabela mais tarde para inserir e recuperar registros para demonstrar como o MySQL BLOB funciona.

      Faça log-off do servidor MySQL:

      Em seguida, faça login novamente com as credenciais do test_user que você criou:

      Quando solicitado, digite a senha para o test_user e tecle ENTER para continuar. Em seguida, alterne para o banco de dados test_company digitando o seguinte:

      Assim que o banco de dados test_company for selecionado, o MySQL exibirá:

      Output

      Database changed

      Em seguida, crie uma tabela products executando:

      • CREATE TABLE `products` (product_id BIGINT PRIMARY KEY AUTO_INCREMENT, product_name VARCHAR(50), price DOUBLE, product_image BLOB) ENGINE = InnoDB;

      Este comando cria uma tabela com nome products. A tabela tem quatro colunas:

      • product_id: esta coluna utiliza um tipo de dados BIGINT para acomodar uma grande lista de produtos até um máximo de 2⁶³-1 items. Você marcou a coluna como PRIMARY KEY para identificar unicamente os produtos. Para que o MySQL trate da geração de novos identificadores para as colunas inseridas, você usou a palavra-chave AUTO_INCREMENT.

      • product_name: esta coluna contém os nomes dos produtos. Você usou o tipo de dados VARCHAR já que este campo geralmente irá lidar com alfanuméricos com um máximo de 50 caracteres — o limite de 50 é apenas um valor hipotético usado para o propósito deste tutorial.

      • price: para fins de demonstração, sua tabela products contém a coluna de preço para armazenar o preço de varejo dos produtos. Como alguns produtos podem ter valores de ponto flutuante (por exemplo, 23.69, 45.36, 102.99), você utilizou o tipo de dados DOUBLE.

      • product_image: esta coluna utiliza um tipo de dados BLOB para armazenar os dados do binário real das imagens dos produtos.

      Você usou o InnoDB storage ENGINE para que a tabela suporte uma grande variedade de recursos, incluindo as transações do MySQL. Após executar isso para criar a tabela de products, você verá a seguinte saída:

      Output

      Query OK, 0 rows affected (0.03 sec)

      Saia do seu servidor MySQL:

      Você receberá a seguinte saída:

      Output

      Bye

      A tabela products agora está pronta para armazenar alguns registros, incluindo imagens de produtos e você a preencherá com alguns produtos no próximo passo.

      Neste passo, você criará um script PHP que se conectará ao banco de dados MySQL que você criou no Passo 1. O script preparará três produtos de exemplo e os inserirá na tabela products.

      Para criar o código PHP, abra um novo arquivo com seu editor de texto:

      • sudo nano /var/www/html/config.php

      Em seguida, digite as seguintes informações no arquivo e substitua PASSWORD pela senha do test_user que você criou no Passo 1:

      /var/www/html/config.php

      <?php
      
      define('DB_NAME', 'test_company');
      define('DB_USER', 'test_user');
      define('DB_PASSWORD', 'PASSWORD');
      define('DB_HOST', 'localhost');
      
      $pdo = new PDO("mysql:host=" . DB_HOST . "; dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
      $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
      
      

      Salve e feche o arquivo.

      Neste arquivo, você usou quatro constantes PHP para se conectar ao banco de dados MySQL que você criou no Passo 1:

      • DB_NAME esta constante contém o nome do banco de dados test_company.

      • DB_USER: esta variável contém o nome de usuário test_user.

      • DB_PASSWORD : esta constante armazena a PASSWORD MySQL da conta do test_user.

      • DB_HOST: isso representa o servidor onde o banco de dados está. Neste caso, você está usando o servidor localhost.

      A seguinte linha em seu arquivo inicia um PHP Data Object (PDO) e se conecta ao banco de dados MySQL:

      ...
      $pdo = new PDO("mysql:host=" . DB_HOST . "; dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
      ...
      

      Perto do final do arquivo, você definiu alguns atributos PDO:

      • ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION: este atributo instrui o PDO a lançar uma exceção que pode ser logada para fins de depuração.
      • ATTR_EMULATE_PREPARES, false: esta opção aumenta a segurança ao informar ao o mecanismo de banco de dados do MySQL para fazer a preparação ao invés do PDO.

      Você incluirá o arquivo /var/www/html/config.php em dois scripts PHP que você criará a seguir para inserir e recuperar registros, respectivamente.

      Primeiro, crie o script PHP /var/www/html/insert_products.php para inserir registros na tabela products:

      • sudo nano /var/www/html/insert_products.php

      Em seguida, adicione as seguintes informações no arquivo /var/www/html/insert_products.php

      /var/www/html/insert_products.php

      <?php
      
      require_once 'config.php';
      
      $products = [];
      
      $products[] = [
                    'product_name' => 'VIRTUAL SERVERS',
                    'price' => 5,
                    'product_image' => file_get_contents("https://i.imgur.com/VEIKbp0.png")
                    ];
      
      $products[] = [
                    'product_name' => 'MANAGED KUBERNETES',
                    'price' => 30,
                    'product_image' => file_get_contents("https://i.imgur.com/cCc9Gw9.png")
                    ];
      
      $products[] = [
                    'product_name' => 'MySQL DATABASES',
                    'price' => 15,
                    'product_image' => file_get_contents("https://i.imgur.com/UYcHkKD.png" )
                    ];
      
      $sql = "INSERT INTO products(product_name, price, product_image) VALUES (:product_name, :price, :product_image)";
      
      foreach ($products as $product) {
          $stmt = $pdo->prepare($sql);
          $stmt->execute($product);
      }
      
      echo "Records inserted successfully";
      

      Salve e feche o arquivo.

      No arquivo, você incluiu o arquivo config.php no topo. Este é o primeiro arquivo que você criou para definir as variáveis de banco de dados e se conectar ao banco de dados. O arquivo também inicia um objeto PDO e o armazena em uma variável $pdo.

      Em seguida, você criou uma matriz de dados dos produtos para serem inseridos no banco de dados. Além de product_name e price, que são preparados como strings e valores numéricos respectivamente, o script utiliza a função integrada do PHP file_get_contents para ler imagens de uma origem externa e as passar como strings para a coluna product_image.

      Em seguida, você preparou uma instrução SQL e usou a instrução PHP foreach{...} para inserir cada produto no banco de dados.

      Para executar o arquivo /var/www/html/insert_products.php execute-o na janela do seu navegador usando a seguinte URL. Lembre-se de substituir your-server-IP pelo endereço IP público do seu servidor:

      http://your-server-IP/insert_products.php
      

      Após executar o arquivo, você verá uma mensagem de sucesso em seu navegador, confirmando que os registros foram inseridos no banco de dados.

      Uma mensagem mostrando que os registros foram inseridos com sucesso no banco de dados

      Você inseriu com sucesso três registros contendo imagens de produtos na tabela products. No próximo passo, você criará um script PHP para recuperar esses registros e exibi-los no seu navegador.

      Passo 3 — Exibindo Informações de Produtos do Banco de Dados MySQL

      Com as informações e imagens dos produtos no banco de dados, você agora irá programar outro script PHP que consulta e exibe informações dos produtos em uma tabela HTML no seu navegador.

      Para criar o arquivo, digite o seguinte:

      • sudo nano /var/www/html/display_products.php

      Em seguida, digite as seguintes informações no arquivo:

      /var/www/html/display_products.php

      <html>
        <title>Using BLOB and MySQL</title>
        <body>
      
        <?php
      
        require_once 'config.php';
      
        $sql = "SELECT * FROM products";
        $stmt = $pdo->prepare($sql);
        $stmt->execute();
        ?>
      
        <table border="1" align = 'center'> <caption>Products Database</caption>
          <tr>
            <th>Product Id</th>
            <th>Product Name</th>
            <th>Price</th>
            <th>Product Image</th>
          </tr>
      
        <?php
        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
            echo '<tr>';
            echo '<td>' . $row['product_id'] . '</td>';
            echo '<td>' . $row['product_name'] . '</td>';
            echo '<td>' . $row['price'] . '</td>';
            echo '<td>' .
            '<img src = "data:image/png;base64,' . base64_encode($row['product_image']) . '" width = "50px" height = "50px"/>'
            . '</td>';
            echo '</tr>';
        }
        ?>
      
        </table>
        </body>
      </html>
      

      Salve as alterações no arquivo e feche-o.

      Aqui, você incluiu novamente o arquivo config.php para se conectar ao banco de dados. Em seguida, você preparou e executou uma instrução SQL usando o PDO para recuperar todos os itens da tabela products usando o comando SELECT * FROM products

      Depois, você criou uma tabela HTML e a preencheu com os dados dos produtos usando a instrução PHP while() {...}. A linha $row = $stmt->fetch(PDO::FETCH_ASSOC) consulta o banco de dados e armazena o resultado na variável $row como uma matriz multidimensional, que você então exibiu em uma coluna de tabela HTML usando a sintaxe $row['column_name'].

      As imagens da coluna product_image são incluídas dentro das tags <img src = "">. Você usou os atributos width e height para redimensionar as imagens para um tamanho menor que pode se encaixar na coluna HTML.

      Para converter os dados mantidos pelo tipo de dados BLOB de volta para imagens, você usou a função PHP integrada base64_encode e a seguinte sintaxe para o esquema Data URI:

      data:media_type;base64, base_64_encoded_data
      

      Neste caso, o image/png é o media_type e a string codificada em Base64 da coluna product_image é o base_64_encoded_data.

      Em seguida, execute o arquivo display_products.php em um navegador web digitando o seguinte endereço:

      http://your-server-IP/display_products.php
      

      Após executar o arquivo display_products.php em seu navegador, você verá uma tabela HTML com uma lista de produtos e imagens associadas.

      List of products from MySQL database

      Isso confirma que o script PHP para recuperar imagens do MySQL está funcionando como esperado.

      Conclusão

      Neste guia, você utilizou o tipo de dados MySQL BLOB para armazenar e exibir imagens com PHP no Ubuntu 18.04. Você também viu as vantagens básicas de armazenar imagens em um banco de dados, ao invés de armazená-las em um sistema de arquivos. Elas incluem a portabilidade, segurança e facilidade de backup. Se você estiver construindo uma aplicação como um portal de estudantes ou o banco de dados de funcionários que exige que informações e imagens relacionadas sejam armazenadas em conjunto, então essa tecnologia pode ser de grande uso para você.

      Para obter mais informações sobre os tipos de dados suportados no MySQL, siga o guia MySQL Data Types. Se você estiver interessado em mais conteúdos relacionados ao MySQL e ao PHP, verifique os seguintes tutoriais:



      Source link

      Como Remover Imagens Docker, Contêineres e Volumes


      Um Guia de Consulta Rápida do Docker

      Introdução

      O Docker facilita o agrupamento de suas aplicações e serviços em contêineres de forma que você possa executá-los em qualquer lugar. Ao trabalhar com o Docker, no entanto, também é fácil acumular um número excessivo de imagens, contêineres e volumes de dados não utilizados que atrapalham a saída e consomem espaço em disco.

      O Docker lhe fornece todas as ferramentas que você precisa para limpar seu sistema a partir da linha de comando. Este guia no estilo cheat sheet fornece uma referência rápida para comandos que são úteis para liberar espaço em disco e manter seu sistema organizado, removendo imagens Docker não utilizadas, contêineres e volumes.

      Como Usar Este Guia:

      • Este guia está no formato de consulta rápida, com trechos de linha de comando independentes.
      • Vá para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      A sintaxe de substituição de comando, comando $(comando), usada nos comandos está disponível em muitos shells populares, como o bash, zsh e Windows Powershell.

      Limpando Todas as Imagens, Contêineres, Volumes e Redes não Utilizadas ou Pendentes

      O Docker fornece um único comando que irá limpar quaisquer recursos — imagens, contêineres, volumes, e redes — que estão pendentes (não associados a um contêiner):

      Para remover adicionalmente quaisquer contêineres e todas as imagens não utilizadas (não apenas imagens pendentes), adicione a flag -a ao comando:

      Removendo Imagens Docker

      Remover uma ou mais imagens específicas

      Use o comando docker images com a flag -a para localizar o ID das imagens que você deseja remover. Isso lhe mostrará todas as imagens, incluindo camadas intermediárias de imagem. Quando você tiver localizado as imagens que deseja excluir, você pode passar o ID ou tag delas para o docker rmi:

      Listar:

      Remover:

      Remover imagens pendentes

      As imagens Docker consistem de várias camadas. As imagens pendentes são camadas que não têm relação com nenhuma imagem marcada. Elas não servem a um propósito e consomem espaço em disco. Elas podem ser localizadas adicionando a sinalização de filtro, -f com um valor de dangling=true ao comando docker images. Quando você tiver certeza de que deseja excluí-las, você pode usar o comando docker images purge:

      Nota: se você construir uma imagem sem marcá-la, ela aparecerá na lista de imagens pendentes porque ela não possui nenhuma associação com uma imagem marcada. Você pode evitar esta situação fornecendo uma tag quando você for compilar, e você marcar retroativamente uma imagem com o comando docker tag.

      Listar:

      • docker images -f dangling=true

      Remover:

      Removendo imagens de acordo com um padrão

      Você pode encontrar todas as imagens que correspondem a um padrão usando uma combinação do docker images e grep. Assim que estiver satisfeito, você pode excluí-las usando o awk para passar os IDs para o docker rmi. Observe que esses utilitários não são fornecidos pelo Docker e não estão necessariamente disponíveis em todos os sistemas:

      Listar:

      • docker images -a | grep "pattern"

      Remover:

      • docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

      Remover todas as imagens

      Todas as imagens Docker em um sistema podem ser listadas adicionando -a ao comando docker images. Assim que tiver certeza de que você deseja excluir todas elas, você pode adicionar a sinalização -q para passar o ID da Imagem para o docker rmi:

      Listar:

      Remover:

      • docker rmi $(docker images -a -q)

      Removendo Contêineres

      Remover um ou mais contêineres específicos

      Use o comando docker ps com a sinalização -a para localizar o nome e o ID dos contêineres que você deseja remover.

      Listar:

      Remover:

      • docker rm ID_or_Name ID_or_Name

      Remover um contêiner ao sair

      Se você sabe, ao criar um contêiner, que você não irá querer mantê-lo por perto assim que terminar, você pode executar docker run --rm para excluí-lo automaticamente quando ele for fechado.

      Executar e Remover:

      • docker run --rm image_name

      Remover todos os contêineres finalizados

      Você pode localizar contêineres usando o docker ps -a e filtrá-los pelo seu status: created, restarting, running, paused, or exited. Para revisar a lista de contêineres finalizados, use a flag -f para filtrar com base no status. Quando você tiver verificado, você deseja remover esses contêineres, usando -q para passar os IDs para o comando docker rm.

      Listar:

      • docker ps -a -f status=exited

      Remover:

      • docker rm $(docker ps -a -f status=exited -q)

      Remover contêineres usando mais de um filtro.

      Os filtros do Docker podem ser combinados repetindo a sinalização de filtro com um valor adicional. Isso resulta em uma lista de contêineres que correspondem a qualquer das condições. Por exemplo, se você quiser excluir todos contêineres marcados como Created (um estado que pode resultar quando você executa um contêiner com um comando inválido) ou Exited, você pode usar dois filtros:

      Listar:

      • docker ps -a -f status=exited -f status=created

      Remover:

      • docker rm $(docker ps -a -f status=exited -f status=created -q)

      Remover contêineres de acordo com um padrão

      Você pode encontrar todos os contêineres que correspondem a um padrão usando uma combinação de docker ps e grep. Quando você estiver satisfeito com a lista que deseja excluir, você pode usar o awk e o xargs para fornecer o ID para o docker rmi. Observe que esses utilitários não são fornecidos pelo Docker e não estão necessariamente disponíveis em todos os sistemas:

      Listar:

      • docker ps -a | grep "pattern

      Remover:

      • docker ps -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

      Parar e remover todos os contêineres

      Você pode revisar os contêineres em seu sistema com o docker ps. Adicionando a flag -a mostrará todos os contêineres. Quando você tiver certeza de que deseja excluí-los, você pode adicionar a flag -q para fornecer os IDs para os comandos docker stop e docker rm:

      Listar:

      Remover:

      • docker stop $(docker ps -a -q)
      • docker rm $(docker ps -a -q)

      Removendo Volumes

      Remover um ou mais volumes específicos – Docker 1.9 e mais recentes

      Use o comando docker volume ls para localizar o nome ou nomes de volume que você deseja excluir. Em seguida, você pode remover um ou mais volumes com o comando docker volume rm:

      Listar:

      Remover:

      • docker volume rm volume_name volume_name

      Remover volumes pendentes – Docker 1.9 e acima

      Como a ideia de volumes é existir independentemente dos contêineres, quando um contêiner é removido, um volume não é removido automaticamente ao mesmo tempo. Quando um volume existe e não está mais conectado a nenhum contêiner, ele é chamado de volume pendente, ou dangling volume. Para localizá-los para confirmar que você deseja removê-los, você pode usar o comando docker volume ls com um filtro para limitar os resultados aos volumes pendentes. Quando você estiver satisfeito com a lista, você pode remover todos eles com docker volume prune:

      Listar:

      • docker volume ls -f dangling=true

      Remover:

      Remover um contêiner e seu volume

      Se você criou um volume não nomeado, ele pode ser excluído ao mesmo tempo que o contêiner com a sinalização -v. Observe que isso funciona apenas com volumes não nomeados. Quando o contêiner for removido com sucesso, seu ID é exibido. Observe que nenhuma referência é feita à remoção do volume. Se ele está sem nome, ele é removido silenciosamente do sistema. Se ele está nomeado, ele permanece silenciosamente presente.

      Remover:

      • docker rm -v container_name

      Conclusão

      Este guia cobre alguns dos comandos comuns usados para remover imagens, contêineres e volumes com o Docker. Há muitas outras combinações e flags que podem ser usadas com cada um deles. Para um guia abrangente sobre o que está disponível, consulte a documentação do Docker para docker system prune, docker rmi, docker rm, e docker volume rm. Se houver tarefas comuns de limpeza que você gostaria de ver no guia, por favor, pergunte ou faça sugestões nos comentários.



      Source link

      Como Criar e Exibir Imagens WebP para Acelerar Seu Website


      O autor selecionou a Apache Software Foundationpara receber uma doação como parte do programa Write for DOnations.

      Introdução

      WebP é um formato aberto de imagem desenvolvido pelo Google em 2010, baseado no formato de vídeo VP8. Desde então, o número de sites e aplicativos móveis que usam o formato WebP cresceu rapidamente. Tanto o Google Chrome como o Opera suportam o formato WebP de forma nativa e, uma vez que esses navegadores representam cerca de 74% do tráfego da Web, os usuários podem acessar sites mais rapidamente se esses sites usarem imagens WebP. Também existem planos para implementar o WebP no Firefox.

      O formato WebP suporta tanto a compressão de imagens com perda, quanto sem perda de dados, incluindo animação. Sua princpal vantagem em comparação com outros formatos de imagem usados na Web é o tamanho bastante reduzido dos arquivos, o que permite que as páginas Web carreguem mais rapidamente e reduz o uso de largura de banda. Usar imagens WebP pode levar a aumentos consideráveis na velocidade da página. Se o seu aplicativo ou site estiver passando por problemas de desempenho ou aumento de tráfego, converter suas imagens pode ajudar a otimizar o desempenho das páginas.

      Neste tutorial, você usará a ferramenta de linha de comando cwebp para converter imagens para o formato WebP, criando scripts que irão ver e converter imagens em um diretório específico. Finalmente, você irá explorar duas maneiras de exibir imagens WebP aos seus visitantes.

      Pré-requisitos

      Trabalhar com imagens WebP não exige uma distribuição específica, mas vamos demonstrar como trabalhar com os software relevantes no Ubuntu 16.04 e CentOS 7. Para seguir este tutorial você precisará de:

      • Um servidor configurado com um usuário não raiz (non-root) de comando sudo. Para configurar um servidor Ubuntu 16.04, você pode seguir nosso Guia de configuração inicial de servidor Ubuntu 16.04. Se você quiser usar o CentOS, você pode configurar um servidor CentOS 7 com nossa Configuração Inicial de Servidor com tutorial CentOS.

      • O Apache instalado no seu servidor. Se você estiver usando o Ubuntu, você pode seguir o passo um do Como Instalar Linux, Apache, MySQL, pilha PHP (LAMP) no Ubuntu 16.04. Se você estiver usando o CentOS, então você deve seguir o passo um do Como Instalar Linux, Apache, MySQL, pilha PHP (LAMP) no CentOS 7. Certifique-se de ajustar as configurações do seu firewall para permitir o tráfego HTTP e HTTPS.

      • mod_rewrite instalado no seu servidor. Se você estiver usando o Ubuntu, você pode seguir nosso guia Como Manipular URLs com mod_rewrite para o Apache no Ubuntu 16.04. No CentOS 7 o mod_rewrite é instalado e ativado por padrão.

      Passo 1 — Instalando o cwebp e Preparando o Diretório de Imagens

      Nesta seção, instalaremos o software para converter imagens e criaremos um diretório com imagens para a finalidade de teste.

      No Ubuntu 16.04, você pode instalar o cwebp, um utilitário que comprime imagens no formato .webp, digitando:

      • sudo apt-get update
      • sudo apt-get install webp

      No CentOS 7, digite:

      • sudo yum install libwebp-tools

      Para criar um novo diretório de imagens chamado webp no diretório raiz do Apache Web (localizado por padrão em /var/www/html) digite:

      • sudo mkdir /var/www/html/webp

      Altere o proprietário deste diretório para o seu usuário sammy não raiz:

      • sudo chown sammy: /var/www/html/webp

      Para testar comandos, você pode baixar imagens JPEG e PNG gratuitas usando o wget. Esta ferramenta é instalada por padrão no Ubuntu 16.04; se você estiver usando o CentOS 7, você pode instalá-la digitando:

      A seguir, baixe as imagens teste usando os comandos seguintes:

      • wget -c "https://upload.wikimedia.org/wikipedia/commons/2/24/Junonia_orithya-Thekkady-2016-12-03-001.jpg?download" -O /var/www/html/webp/image1.jpg
      • wget -c "https://upload.wikimedia.org/wikipedia/commons/5/54/Mycalesis_junonia-Thekkady.jpg" -O /var/www/html/webp/image2.jpg
      • wget -c "https://cdn.pixabay.com/photo/2017/07/18/15/39/dental-care-2516133_640.png" -O /var/www/html/webp/logo.png

      Nota: estas imagens estão disponíveis para uso e redistribuição sob a licença Creative Commons Attribution-ShareAlike e o Public Domain Dedication.

      A maior parte do seu trabalho no próximo passo estará no diretório /var/www/html/webp, para o qual você pode se mover digitando:

      Com as imagens teste instaladas e o servidor Apache Web, mod_rewrite e cwebp instalados, você está pronto para ir para a conversão de imagens.

      Exibir imagens .webp para visitantes do site exige versões .webp de arquivos de imagem. Neste passo, você irá converter imagens JPEG e PNG para o formato .webp usando o cwebp. A sintaxe geral do comando se parece com essa:

      • cwebp image.jpg -o image.webp

      A opção -o especifica o caminho até o arquivo WebP.

      Uma vez que você ainda está no diretório /var/www/html/webp, você pode executar o comando a seguir para converter a image1.jpg em image1.webp e image2.jpg em image2.webp:

      • cwebp -q 100 image1.jpg -o image1.webp
      • cwebp -q 100 image2.jpg -o image2.webp

      Definir o fator de qualidade -q em 100 retém 100% da qualidade da imagem; se não especificado, o valor padrão é 75.

      A seguir, inspecione o tamanho das imagens JPEG e WebP usando o comando ls. A opção -l irá mostrar o formato de lista longa, que inclui o tamanho do arquivo e a opção -h irá garantir que ls imprima tamanhos legíveis para humanos:

      • ls -lh image1.jpg image1.webp image2.jpg image2.webp

      Output

      -rw-r--r-- 1 sammy sammy 7.4M Oct 28 23:36 image1.jpg -rw-r--r-- 1 sammy sammy 3.9M Feb 18 16:46 image1.webp -rw-r--r-- 1 sammy sammy 16M Dec 18 2016 image2.jpg -rw-r--r-- 1 sammy sammy 7.0M Feb 18 16:59 image2.webp

      O resultado do comando ls mostra que o tamanho da image1.jpg é de 7,4 MB, enquanto o tamanho da image1.webp é 3,9 MB. O mesmo se aplica à image2.jpg (16 MB) e image2.webp (7 MB). Estes arquivos têm quase metade do tamanho original.

      Para salvar os dados das imagens completos e originais durante a compressão, você pode usar a opção -lossless no lugar de -q. Esta é a melhor opção para manter a qualidade de imagens PNG. Para converter a imagem PNG baixada do passo 1, digite:

      • cwebp -lossless logo.png -o https://www.digitalocean.com/logo.webp

      O comando a seguir mostra que o tamanho sem perdas da imagem WebP (60 KB) é aproximadamente metade do tamanho da imagem PNG original (116 KB):

      • ls -lh logo.png https://www.digitalocean.com/logo.webp

      Output

      -rw-r--r-- 1 sammy sammy 116K Jul 18 2017 logo.png -rw-r--r-- 1 sammy sammy 60K Feb 18 16:42 https://www.digitalocean.com/logo.webp

      As imagens convertidas no diretório /var/www/html/webp são cerca de 50% menores do que suas equivalentes em JPEG e PNG. Na prática, as taxas de compressão podem ser diferentes, dependendo de certos fatores: a taxa de compressão da imagem original, o formato do arquivo, o tipo de conversão (com ou sem perdas), a porcentagem de qualidade e o seu sistema operacional. Conforme você for convertendo mais imagens, você poderá ver variações nas taxas de conversão relacionadas a esses fatores.

      Passo 3 — Convertendo Imagens JPEG e PNG em um Diretório

      Escrever um script irá simplificar o processo de conversão, eliminando o trabalho da conversão manual. Agora, vamos escrever um script de conversão que encontre arquivos JPEG e os converta para o formato WebP com 90% da qualidade, enquanto também converte arquivos PNG em imagens WeP sem perdas.

      Usando o nano ou seu editor favorito, crie o script webp-convert.sh no diretório home do seu usuário.

      A primeira linha do script se parecerá com esta:

      ~/webp-convert.sh

      find $1 -type f -and ( -iname "*.jpg" -o -iname "*.jpeg" )
      

      Esta linha tem os seguintes componentes:

      • find: este comando irá procurar por arquivos dentro de um diretório especificado.
      • $1: este parâmetro posicional especifica o caminho do diretório de imagens, tirado da linha de comando. Em última análise, ele torna o local do diretório menos dependente do local do script.
      • -type f: esta opção diz ao find para procurar apenas arquivos regulares.
      • -iname: este teste compara os nomes dos arquivos com um padrão especificado. O teste -iname que não diferencia maiúsculas de minúsculas diz ao find para procurar qualquer nome de arquivo que termine com .jpg (*.jpg) ou .jpeg (*.jpeg).
      • -o: Este operador lógico instrui o comando find para listar arquivos que correspondam ao primeiro teste -iname (-iname ".jpg"**) ou o segundo (-iname "*.jpeg"**).
      • (): parênteses em volta desses testes, junto com o operador -and, garante que o primeiro teste (ou seja -type f) seja sempre executado.

      A segunda linha do script irá converter as imagens para WebP usando o parâmetro -exec. A sintaxe geral deste parâmetro é -exec command {} ;. Cada arquivo substitui uma string {}; o comando faz a iteração através desses arquivos, ao passo que a string ; diz para o find onde o comando termina:

      ~/webp-convert.sh

      find $1 -type f -and ( -iname "*.jpg" -o -iname "*.jpeg" ) 
      -exec bash -c 'commands' {} ;
      

      Neste caso, o parâmetro -exec irá exigir mais de um comando para procurar e converter imagens:

      • bash: este comando irá executar um pequeno script que irá criar a versão .webp do arquivo se ele não existir. Este script será passado para o bash como uma string, graças à opção -c.
      • 'commands': este espaço reservado é o script que irá fazer versões .webp dos seus arquivos.

      O script dentro de 'commands' fará as seguintes coisas:

      • Criar uma variável webp_path.
      • Testar se a versão .webp do arquivo existe ou não.
      • Criar o arquivo se ele não existir.

      O script menor se parece com este:

      ~/webp-convert.sh

      ...
      webp_path=$(sed 's/.[^.]*$/.webp/' <<< "$0");
      if [ ! -f "$webp_path" ]; then 
        cwebp -quiet -q 90 "$0" -o "$webp_path";
      fi;
      

      Os elementos neste script menor incluem:

      • webp_path: esta variável será gerada usando o sed e o nome do arquivo correspondente do comando bash, estipulado pelo pelo parâmetro posicional $0. Uma _string here_ (​​​​​​<<<) passará este nome para o sed.
      • if [ ! -f "$webp_path" ]: este teste irá determinar se um arquivo chamado "$webp_path" já existe, usando o operador lógico not (!).
      • cwebp: este comando irá criar o arquivo se ele não existir, usando a opção -q para não imprimir o resultado.

      Com este script menor no lugar do espaço reservado 'commands', o script completo para converter imagens JPEG se parecerá agora com este:

      ~/webp-convert.sh

      # converting JPEG images
      find $1 -type f -and ( -iname "*.jpg" -o -iname "*.jpeg" ) 
      -exec bash -c '
      webp_path=$(sed 's/.[^.]*$/.webp/' <<< "$0");
      if [ ! -f "$webp_path" ]; then 
        cwebp -quiet -q 90 "$0" -o "$webp_path";
      fi;' {} ;
      

      Para converter imagens PNG para WebP, vamos adotar a mesma abordagem, com duas diferenças: primeiro, o padrão -iname no comando find será "*.png". Segundo, o comando de conversão usará a opção -lossless em vez da opção de qualidade -q.

      O script final se parece com este:

      ~/webp-convert.sh

      #!/bin/bash
      
      # converting JPEG images
      find $1 -type f -and ( -iname "*.jpg" -o -iname "*.jpeg" ) 
      -exec bash -c '
      webp_path=$(sed 's/.[^.]*$/.webp/' <<< "$0");
      if [ ! -f "$webp_path" ]; then 
        cwebp -quiet -q 90 "$0" -o "$webp_path";
      fi;' {} ;
      
      # converting PNG images
      find $1 -type f -and -iname "*.png" 
      -exec bash -c '
      webp_path=$(sed 's/.[^.]*$/.webp/' <<< "$0");
      if [ ! -f "$webp_path" ]; then 
        cwebp -quiet -lossless "$0" -o "$webp_path";
      fi;' {} ;
      

      Salve o arquivo e saia do editor.

      Em seguida, vamos colocar o script webp-convert.sh em prática, usando os arquivos no diretório /var/www/html/webp. Certifique-se de que o arquivo script é executável, executando o comando a seguir:

      • chmod a+x ~/webp-convert.sh

      Execute o script no diretório de imagens:

      • ./webp-convert.sh /var/www/html/webp

      Nada aconteceu! Isso se dá porque já convertemos essas imagens no passo 2. Avançando, o script webp-convert converterá imagens quando adicionarmos novos arquivos ou removermos as versões .webp. Para ver como isso funciona, exclua os arquivos .webp que criamos no passo 2:

      • rm /var/www/html/webp/*.webp

      Após excluir todas as imagens .webp, execute o script novamente para garantir que ele funciona:

      • ./webp-convert.sh /var/www/html/webp

      O comando ls confirmará que o script converteu as imagens com sucesso:

      • ls -lh /var/www/html/webp

      Output

      -rw-r--r-- 1 sammy sammy 7.4M Oct 28 23:36 image1.jpg -rw-r--r-- 1 sammy sammy 3.9M Feb 18 16:46 image1.webp -rw-r--r-- 1 sammy sammy 16M Dec 18 2016 image2.jpg -rw-r--r-- 1 sammy sammy 7.0M Feb 18 16:59 image2.webp -rw-r--r-- 1 sammy sammy 116K Jul 18 2017 logo.png -rw-r--r-- 1 sammy sammy 60K Feb 18 16:42 https://www.digitalocean.com/logo.webp

      O script neste passo é a base para usar imagens WebP no seu site, uma vez que você precisará de uma versão m funcionamento de todas as imagens no formato WebP para exibir aos visitantes. O próximo passo abordará como automatizar a conversão de novas imagens.

      Passo 4 — Monitorando Arquivos de Imagem em um Diretório

      Neste passo, criaremos um novo script para monitorar nosso diretório de imagens quanto a alterações e para converter automaticamente as imagens recém-criadas.

      Criar um script que monitora nosso diretório de imagens pode resolver certos problemas com o script webp-convert.sh da forma como ele está escrito. Por exemplo, este script não identificará se renomeamos uma imagem. Se tivéssemos uma imagem chamada foo.jpg, executássemos o webp-convert.sh, renomeássemos aquele arquivo para bar.jpg e, então, executássemos o webp-convert.sh novamente, teríamos arquivos duplicados de .webp (foo.webp e bar.webp). Para resolver este problema e para evitar executar o script manualmente, adicionaremos observadores a outro script. Os observadores monitoram os arquivos ou diretórios especificados quanto às alterações e executam comandos em resposta a essas alterações.

      O comando inotifywait irá configurar observadores no nosso script. Este comando faz parte do pacote inotify-tools, um conjunto de ferramentas de linha de comando que fornecem uma interface simples ao subsistema do kernel inotify. Para instalá-lo no Ubuntu 16.04 digite:

      • sudo apt-get install inotify-tools

      Com o CentOS 7, o pacote inotify-tools está disponível no repositório EPEL. Instale o repositório EPEL e o pacote inotify-tools usando os comandos a seguir:

      • sudo yum install epel-release
      • sudo yum install inotify-tools

      Em seguida, crie o script webp-watchers.sh no diretório home do seu usuário usando o nano:

      A primeira linha do script se parecerá com esta:

      ~/webp-watchers.sh

      inotifywait -q -m -r --format '%e %w%f' -e close_write -e moved_from -e moved_to -e delete $1
      

      Esta linha inclui os seguintes elementos:

      • inotifywait: este comando monitora quanto às alterações em um certo diretório.
      • -q: esta opção irá dizer ao inotifywait para ficar quieto e não produzir grande quantidade de resultados.
      • -m: esta opção irá dizer ao inotifywait para executar indefinidamente e não sair após receber um único evento.
      • -r: esta opção irá configurar observadores de maneira repetitiva, monitorando um diretório especificado e todos os seus subdiretórios.
      • --format: esta opção diz ao inotifywait para monitorar alterações usando o nome do evento seguido do caminho do arquivo. Os eventos que queremos monitorar são close_write (acionado quando um arquivo é criado e completamente gravado no disco), moved_from e moved_to (acionados quando um arquivo é movido) e delete (acionado quando um arquivo é excluído).
      • $1: este parâmetro posicional retém o caminho dos arquivos alterados.

      Na sequência, vamos adicionar um comando grep para determinar se nossos arquivos são imagens JPEG ou PNG. A opção -i irá dizer ao grep para ignorar a diferença entre maiúsculas e minúsculas; -E irá especificar que o grep deve usar expressões regulares estendidas e a --line-buffered irá dizer ao grep para passar as linhas correspondentes para um loop while:

      ~/webp-watchers.sh

      inotifywait -q -m -r --format '%e %w%f' -e close_write -e moved_from -e moved_to -e delete $1 | grep -i -E '.(jpe?g|png)$' --line-buffered
      

      A seguir, vamos construir um loop while com o comando read. O read irá processar o evento que o inotifywait detectou, atribuindo-o a uma variável chamada $operation e o caminho do arquivo processado para uma variável chamada $path:

      ~/webp-watchers.sh

      ...
      | while read operation path; do
        # commands
      done;
      

      Vamos combinar este loop com o resto do nosso script:

      ~/webp-watchers.sh

      inotifywait -q -m -r --format '%e %w%f' -e close_write -e moved_from -e moved_to -e delete $1 
      | grep -i -E '.(jpe?g|png)$' --line-buffered 
      | while read operation path; do
        # commands
      done;
      

      Após o loop while verificar o evento, os comandos dentro do loop tomarão as seguintes ações, dependendo do resultado:

      • Criar um novo arquivo WebP se um novo arquivo de imagem for criado ou movido para o diretório de destino.
      • Excluir o arquivo WebP se o arquivo de imagem associado for excluído ou movido do diretório de destino.

      Há três seções principais dentro do loop. Uma variável chamada webp_path irá reter o caminho para a versão .webp da imagem em questão:

      ~/webp-watchers.sh

      ...
      webp_path="$(sed 's/.[^.]*$/.webp/' <<< "$path")";
      

      A seguir, o script irá testar qual evento aconteceu:

      ~/webp-watchers.sh

      ...
      if [ $operation = "MOVED_FROM" ] || [ $operation = "DELETE" ]; then
        # commands to be executed if the file is moved or deleted
      elif [ $operation = "CLOSE_WRITE,CLOSE" ] || [ $operation = "MOVED_TO" ]; then
        # commands to be executed if a new file is created
      fi;
      

      Se o arquivo foi movido ou excluído, o script irá verificar se a versão .webp existe. Se ela existe, o script irá removê-la usando o rm:

      ~/webp-watchers.sh

      ...
      if [ -f "$webp_path" ]; then
        $(rm -f "$webp_path");
      fi;
      

      Para arquivos recém-criados, a compressão irá acontecer da seguinte forma:

      • Se o arquivo correspondente for uma imagem PNG, o script irá usar a compressão sem perdas.
      • Se não for, o script usará uma compressão com perdas com a opção -quality.

      Vamos adicionar os comandos cwebp que irão fazer este trabalho no script:

      ~/webp-watchers.sh

      ...
      if [ $(grep -i '.png$' <<< "$path") ]; then
        $(cwebp -quiet -lossless "$path" -o "$webp_path");
      else
        $(cwebp -quiet -q 90 "$path" -o "$webp_path");
      fi;
      

      Na íntegra, o arquivo webp-watchers.sh se parecerá com este:

      ~/webp-watchers.sh

      #!/bin/bash
      echo "Setting up watches.";
      
      # watch for any created, moved, or deleted image files
      inotifywait -q -m -r --format '%e %w%f' -e close_write -e moved_from -e moved_to -e delete $1 
      | grep -i -E '.(jpe?g|png)$' --line-buffered 
      | while read operation path; do
        webp_path="$(sed 's/.[^.]*$/.webp/' <<< "$path")";
        if [ $operation = "MOVED_FROM" ] || [ $operation = "DELETE" ]; then # if the file is moved or deleted
          if [ -f "$webp_path" ]; then
            $(rm -f "$webp_path");
          fi;
        elif [ $operation = "CLOSE_WRITE,CLOSE" ] || [ $operation = "MOVED_TO" ]; then  # if new file is created
           if [ $(grep -i '.png$' <<< "$path") ]; then
             $(cwebp -quiet -lossless "$path" -o "$webp_path");
           else
             $(cwebp -quiet -q 90 "$path" -o "$webp_path");
           fi;
        fi;
      done;
      

      Salve e feche o arquivo. Não se esqueça de torná-lo executável:

      • chmod a+x ~/webp-watchers.sh

      Vamos executar este script no diretório /var/www/html/webp em segundo plano, usando o &. Vamos também redirecionar os resultados padrão e os erros padrão para um ~/output.log, para armazenar os resultados em local prontamente disponível:

      • ./webp-watchers.sh /var/www/html/webp > output.log 2>&1 &

      Neste ponto, você converteu os arquivos JPEG e PNG em /var/www/html/webp para o formato WebP e configurou observadores para fazer esse trabalho, usando o script webp-watchers.sh. Agora é hora de explorar opções para entregar imagens WebP aos visitantes do seu site.

      Passo 5 — Exibindo Imagens WebP para Visitantes Usando Elementos HTML

      Neste passo, vamos explicar como exibir imagens WebP com elementos HTML. Neste ponto, devem haver versões .webp de cada uma das imagens teste JPEG e PNG no diretório /var/www/html/webp. Agora, podemos exibi-las para os navegadores compatíveis, usando ou os elementos HTML5 (<picture>) ou o módulo Apache mod_rewrite. Vamos usar elementos HTML neste passo.

      O elemento <picture> permite que você inclua imagens diretamente nas suas páginas Web e defina mais de uma fonte de imagens. Se seu navegador é compatível com o formato WebP, ele irá baixar a versão .webp do arquivo em vez da versão original, resultando em páginas Web sendo exibidas mais rapidamente. Vale dizer que o elemento <picture> é bem suportado em navegadores modernos compatíveis com o formato WebP.

      O elemento <picture> é um container com elementos <source> que <image> apontam para arquivos específicos. Se usarmos <source> para apontar para uma imagem .webp, o navegador verá se ele pode lidar com ela; caso contrário, ele retrocederá para o arquivo de imagem especificado no atributo src do elemento <source>.

      Vamos usar o arquivo logo.png do nosso diretório /var/www/html/webp, o qual convertemos para https://www.digitalocean.com/logo.webp, como um exemplo com <source>. Podemos usar o seguinte código HTML para exibir o https://www.digitalocean.com/logo.webp em qualquer navegador compatível com o formato WebP e o logo.png com navegadors não compatíveis com o WebP ou o elemento <picture>.

      Crie um arquivo HTML localizado em /var/www/html/webp/picture.html:

      • nano /var/www/html/webp/picture.html

      Adicione o código a seguir à página Web para exibir o https://www.digitalocean.com/logo.webp para navegadores compatíveis, usando o elemento <picture>:

      /var/www/html/webp/picture.html

      <picture>
        <source  type="image/webp">
        <img src="https://www.digitalocean.com/logo.png" alt="Site Logo">
      </picture>
      

      Salve e feche o arquivo.

      Para testar se tudo está funcionando, navegue até a página http://your_server_ip/webp/picture.html. Você deve ver a imagem teste PNG.

      Agora que você sabe como exibir imagens .webp diretamente do código HTML, vamos ver como automatizar este processo usando o módulo mod_rewrite do Apache.

      Passo 6 — Exibindo Imagens WebP Usando o mod_rewrite

      Se queremos otimizar a velocidade do nosso site, mas temos um grande número de páginas ou muito pouco tempo para editar o código HTML, então o módulo mod_rewrite do Apache pode nos ajudar a automatizar o processo de exibição de imagens .webp em navegadores compatíveis.

      Primeiramente, crie um arquivo .htaccess no diretório /var/www/html/webp usando o comando a seguir:

      • nano /var/www/html/webp/.htaccess

      A diretiva ifModule irá testar se o mod_rewrite está disponível; se ele estiver, ele pode ser ativado usando o RewriteEngine On. Adicione essas diretivas ao .htaccess:

      /var/www/html/webp/.htaccess

      <ifModule mod_rewrite.c>
        RewriteEngine On 
        # further directives
      </IfModule>
      

      O servidor Web fará vários testes para estabelecer quando exibir imagens .webp para o usuário. Quando um navegador faz um pedido, ele inclui um cabeçalho que indica ao servidor o que o navegador é capaz de manipular. No caso do WebP, o navegador irá enviar um cabeçalho Accept que contém image/webp. Vamos verificar se o navegador enviou aquele cabeçalho usando o RewriteCond, que especifica os critérios que devem ser correspondidos para executar o RewriteRule:

      /var/www/html/webp/.htaccess

      ...
      RewriteCond %{HTTP_ACCEPT} image/webp
      

      Tudo deve ser filtrado, exceto as imagens JPEG e PNG. Usando o RewriteCond novamente, adicione uma expressão regular (similar ao que usamos nas seções anteriores) para corresponder ao URI solicitado:

      /var/www/html/webp/.htaccess

      ...
      RewriteCond %{REQUEST_URI}  (?i)(.*)(.jpe?g|.png)$ 
      

      O modificador (?i) fará com que a correspondência não diferencie maiúsculas e minúsculas.

      Para verificar se a versão .webp do arquivo existe, use o RewriteCond novamente do seguinte modo:

      /var/www/html/webp/.htaccess

      ...
      RewriteCond %{DOCUMENT_ROOT}%1.webp -f
      

      Finalmente, se todas as condições anteriores forem cumpridas, o RewriteRule irá redirecionar o arquivo JPEG ou PNG solicitado para seu arquivo WebP associado. Observe que isso irá redirecionar usando o sinalizador -R, em vez de reescrever o URI. A diferença entre reescrever e redirecionar é que o servidor irá exibir o URI reescrito sem contar ao navegador. Por exemplo, o URI irá mostrar que a extensão de arquivo é .png, mas ele será na realidade um arquivo .webp. Adicione o RewriteRule ao arquivo:

      /var/www/html/webp/.htaccess

      ...
      RewriteRule (?i)(.*)(.jpe?g|.png)$ %1.webp [L,T=image/webp,R] 
      

      Neste ponto, a seção mod_rewrite no arquivo .htaccess está completa. Mas o que acontecerá se houver um servidor de cache intermediário entre seu servidor e o cliente? Ele pode exibir a versão errada ao usuário final. É por isso que vale a pena verificar se o mod_headers está habilitado, para enviar o cabeçalho Vary: Accept. O cabeçalho Vary indica aos servidores de cache (como servidores proxy) que o tipo de conteúdo do documento varia dependendo das capacidades do navegador que solicita o documento. Além disso, a resposta será gerada com base no cabeçalho Accept no pedido. Um pedido com um cabeçalho Accept diferente pode obter uma resposta diferente. Este cabeçalho é importante porque ele impede que imagens WebP em cache sejam exibidas para navegadores não compatíveis:

      /var/www/html/webp/.htaccess

      ...
      <IfModule mod_headers.c>
        Header append Vary Accept env=REDIRECT_accept
      </IfModule>
      

      Enfim, no final do arquivo .htaccess, configure o tipo MIME das imagens .webp como image/webp usando a diretiva AddType. Isso irá exibir as imagens usando o tipo de MIME correto:

      /var/www/html/webp/.htaccess

      ...
      AddType image/webp .webp
      

      Esta é a versão final do nosso arquivo .htaccess:

      /var/www/html/webp/.htaccess

      <ifModule mod_rewrite.c>
        RewriteEngine On 
        RewriteCond %{HTTP_ACCEPT} image/webp
        RewriteCond %{REQUEST_URI}  (?i)(.*)(.jpe?g|.png)$ 
        RewriteCond %{DOCUMENT_ROOT}%1.webp -f
        RewriteRule (?i)(.*)(.jpe?g|.png)$ %1.webp [L,T=image/webp,R] 
      </IfModule>
      
      <IfModule mod_headers.c>
        Header append Vary Accept env=REDIRECT_accept
      </IfModule>
      
      AddType image/webp .webp
      

      Nota: você pode fundir este .htaccess com outro arquivo .htaccess, se ele existir. Se você está usando o WordPress, por exemplo, você deve copiar este arquivo .htaccess e colá-lo no topo do arquivo existente.

      Vamos colocar o que fizemos neste passo em prática. Se você seguiu as instruções nos passos anteriores, você deve ter as imagens logo.png e https://www.digitalocean.com/logo.webp em /var/www/html/webp. Vamos usar uma tag simples <img> para incluir a logo.png em nossa página Web. Crie um novo arquivo HTML para testar a configuração:

      • nano /var/www/html/webp/img.html

      Digite o código HTML a seguir no arquivo:

      /var/www/html/webp/img.html

      <img src="https://www.digitalocean.com/logo.png" alt="Site Logo">
      

      Salve e feche o arquivo.

      Quando você visitar a página Web usando o Chrome visitando http://your_server_ip/webp/img.html, você irá notar que a imagem exibida é a versão .webp (tente abrir a imagem em uma nova aba). Se você usa o Firefox, você receberá uma imagem .png automaticamente.

      Conclusão

      Neste tutorial, abordamos técnicas básicas para trabalhar com imagens WebP. Explicamos como usar o cwebp para converter arquivos, além de duas opções para exibir essas imagens aos usuários: o elemento <picture> do HTML5 e o mod_rewrite do Apache.

      Para personalizar os scripts deste tutorial, você pode consultar alguns desses recursos:

      • Para aprender mais sobre as características do formato WebP e como usar as ferramentas de conversão, consulte a documentação do WebP.
      • Para ver mais detalhes sobre o uso do elemento <picture>, consulte sua documentação no MDN.
      • Para entender completamente como usar o mod_rewrite, consulte sua documentação.

      Usar o formato WebP para suas imagens irá reduzir os tamanhos dos arquivos de maneira considerável. Isso pode reduzir o uso da largura de banda e fazer as páginas carregarem mais rapidamente, particularmente se seu site usar muitas imagens.



      Source link