Diolinux - O modo Linux e Open Source de ver o Mundo

Responsive Ad Slot

Mostrando postagens com marcador shell. Mostrar todas as postagens
Mostrando postagens com marcador shell. Mostrar todas as postagens

Curso EXTREMAMENTE AVANÇADO de Shell Script!

Nenhum comentário

segunda-feira, 24 de junho de 2019

Agora que você já perdeu o medo do terminal Linux chegou a hora de dar um passo a mais e usar todo o potencial que ele te oferece como uma ferramenta para controle, automação e até diversão, por que não?

Cursos avançado de Shell Script







O meu amigo Marcos, do canal Terminal Root, vem desenvolvendo há muito tempo um material extenso e completo sobre o uso de aplicações em modo texto, terminal e shell script e hoje eu tenho o prazer de anunciar a disponibilidade deste material!

O que você vai aprender se fizer o curso?


Absolutamente tudo sobre manuais, processos, animações em ASCII e Unicode. Vai aprender inúmeros comandos de manipulação de dados do Terminfo e Termcap. Também vai descobrir todo raciocínio e lógica utilizada para criação de games, utilizando a raíz da criação. 

Aprenderá a criar um instalador pra o Arch Linux, bem como manipulação de Sistema de Arquivos via linha de comando. Entre diversos outros tópicos para criar programas profissionais e com recursos UX e UI deixando-os mais intuitivos.

No vídeo à seguir o Marcos te mostra a aplicação prática do Script de instalação do Arch.



São 22 vídeos, mais de 2GB de conteúdo que você pode baixar e guardar com você para sempre, 18 apostilas em PDF, 18 Scripts didáticos e ainda vários arquivos, imagens e outros, tudo isso para te ajudar a estudar e virar um ninja especialista no terminal.

Quanto custa?


O curso possui o valor de investimento de R$ 174,90, porém, um requisito importantíssimo é já ter conhecimento básico ao menos em Shell Script, para que assim você possa desenvolver as habilidades propostas no curso de forma mais rápida.

Caso você não satisfaça esse pré-requisito, o Marcos também preparou alguns cursos que vão te dar toda a base necessária para ir para o curso extremamente avançado.

1 - Curso do Iniciante ao Avançado de Shell Script - Onde você aprenderá o essencial, além de manipular banco de dados e usar Shell Script para Web.

Valor: R$ 39,90.
Mais detalhes em: terminalroot.com.br/bash

2 - Curso do Editor Vim - Você aprenderá a customizar o Vim, podendo por exemplo mapear qualquer tecla para responder como deseja.

Valor: R$ 29,90
Mais detalhes em: terminalroot.com.br/vim

3 - Curso Extremamente Avançado em Shell Script Bash - Para criação de animações, instaladores de distros, games e muito mais, como já comentado neste artigo:

Valor: R$ 174,90
Mais informações em: terminalroot.com.br/shell

PORÉM, como aqui não brinca quando o assunto é promoção, agora, em uma parceria entre o Diolinux e o Terminal Root, você pode levar todos os 3 cursos por apenas R$ 179,90!

Um bônus: Além destes cursos mencionados, você também receberá o curso de SED - Editor de fluxo completo.

Como você pode comprar?


Na verdade, de forma muito simples. Todo o material dos cursos será enviado para você por e-mail, então basta fazer a compra aqui.

Depois disso é só aguardar o recebimento do material, se tiver alguma dúvida, entre em contato diretamente com o Marcos em terminalroot.com.br.

Fique ligado no blog e o no canal Diolinux, pois provavelmente sortearemos alguns cursos completos para nossos leitores e inscritos em breve!

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


5 Dicas PRO para Shell Script

Nenhum comentário

segunda-feira, 1 de abril de 2019

Dizem que depois que você aprende o Terminal é que você realmente começa a entender Linux profundamente. Seja isso uma verdade ou não, de fato, é verdade que dominar o terminal te dá algumas vantagens em relação ao que você pode fazer com o seu sistema. Hoje você vai conferir 5 dias para quem quer ser um PRO no Shell Script.







1 - Portabilidade dos seus Shell Script



Muitas vezes indicamos automaticamente o caminho da Shebang como #!/bin/bash, no entanto, se o Bash estiver instalado num diretório diferente (como em sistemas como FreeBSD, OpenBSD e algumas distros Linux) provavelmente ela não conseguirá encontrar o interpretador e seu programa/script não funcionará.

Logo, a melhor maneira de você evitar esse tipo de problema é indicar o caminho da env que é padrão em todos os sistemas e a mesma se encarrega de redirecionar pro caminho onde o interpretador está localizado. Então, procure sempre iniciar seus programas/scripts com o seguinte caminho após a Shebang:

#!/usr/bin/env bash

O mesmo vale para outros Shells: ZSH, FISH, etc.

2 - Procure sempre pôr cabeçalho nos seus scripts


Os cabeçalhos são importantes para que a pessoa saiba pra que serve seu programa/script, como lhe contactar em caso de algum problema, qual a forma de utilização e entre diversos outros pontos positivos.

Geralmente num cabeçalho deve haver o "help", "changelog", "TODO", "FIXME",... ou seja, diversas informações necessárias. No entanto, em resumo, algumas informações são fundamentais, tais como: Descrição do script; Autor; Versão e Licença. Veja abaixo um exemplo mínimo e básico de um cabeçalho:

# autor: Nome Sobrenome <site.dominio>
# descrição: O que seu Script/Programa faz 
# version: 1.0
# licença: MIT License

O exemplo acima está em Português, mas é interessante deixá-lo em Inglês, para ficar ainda mais global.

3 - Separe por função


O motivo inicial da Linguagem Orientada à Objetos é a organização. No entanto, linguagens procedurais ou estruturais podem manter a organização separando cada "transformação" em funções . Em Shell Script, você pode declarar uma função em duas formas de sintax, veja abaixo ambas as formas:

USANDO a palavra function
function minha_funcao(){
echo "Minha função"
}
Ou SEM USAR a palavra function
minha_funcao(){
echo "Minha função"
}
Para chamar a função, basta invocar o nome da função no script, ex.: minha_funcao

4 - Deixe seu código com indentação


No Shell Script, como na maioria das linguagens de programação, a indentação não é obrigatória, no entanto, ela é interessante para deixar seu código mais organizado, então procure sempre manter seu código indentado.

Uma dica legal é se você usar o editor Vim , basta você selecionar tudo pressionando a tecla ESC e em seguinda combinando as teclas ggVG , após tudo selecionado, basta agora teclar duas vezes o sinal de igual == e seu código será automáticamente indentado. Mágica! :)

5 - Declare nomes descritivos


Quando criar nomes de variáveis e de funções, procure descrever (não tanto, lógico) e separando com underline **_** , pois ficará mais profissional e menos provável de haver conflito de nomes e situações desagradáveis, alguns exemplos de como descrever: set_name, get_name, display_info_start, etc.
  
Se você ainda não domina Shell Script e o Terminal Linux. Aproveite uma promoção onde você pode adquirir 5 CURSO DO TERMINAL LINUX incluindo Shell Script, Expressões Regulares, Vim e Sed. Clicando nesse link http://bit.ly/Promo5pg para adquirir com o PagSeguro ou nesse link http://bit.ly/5CursosLinux para adquirir com o PayPal. Se quiser mais detalhes da promoção veja essa postagem: 5 Cursos do Terminal Linux para você! .

Esse artigo foi escrito em parceria com a galera do Terminal Root, os quais são os autores dos cursos mencionados acima, até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Como extrair informações de um vídeo do YouTube usando Shell Script

Nenhum comentário

sábado, 8 de setembro de 2018

O Shell Script pode ser utilizado em lugares muito diferentes e pode servir para automatizar qualquer tarefa que você poderia fazer passo a passo usando a sua distro Linux, hoje vamos aprender a extrair alguns dados do seu canal favorito do YouTube.

Shell Script no YouTube













Para aqueles que são Produtores de Conteúdo com Linux e vivem querendo saber a repercussão do vídeo que acabou de lançar no Youtube , mas está cansado de ficar abrindo toda hora o vídeo pelo navegador, esperando carregar para obter os dados do vídeo como:
  • Inscritos;
  • Gosteis/Likes;
  • Não gosteis/dislikes;
  • Comentários.
Sem dizer também aqueles que acompanham um vídeo que ele gostou e/ou comentou e deseja acompanhar se há novos comentários e etc. Vamos criar um Shell Script que irá nos passar esses dados com um simples comando no terminal linux! Esse exercício faz parte da série Não é magia, é Shell Script! .

Antes de mais nada precisamos criar um cabeçalho, além da Shebang (#!), o cabeçalho precisa de dados do autor, link ou e-mail, licença e a versão do software, logo ficaria assim:

#!/bin/bash
# author:  Marcos Oliveira <diolinux.com.br>
# license: MIT
# version: 1.0

Após isso precisamos criar uma função para pegar os dados do youtube, criamos um arquivo temporário em /tmp com o comando mktemp baixamos a página do youtube relativa a qualquer vídeo e jogamos a saída do wget no nosso arquivo temporário que armazenamos numa variável, leia as linhas que começam com # (comentários):


# Rodamos o comando mktempo numa subshell, logo seu conteúdo 
será armazenado em page_video_youtube 
page_video_youtube=$(mktemp)

# Com a linha abaixo o conteúdo da paǵina HTML será guardado no
arquivo referenciado pela variável
wget "https://www.youtube.com/watch?v=hj-aDdRasGY" -O
$page_video_youtube


Próximo passo agora é filtrar o conteúdo dos dados que baixamos, após abrirmos o arquivo no editor de texto, verificamos que a linha que mostra o ID do canal, possui uma string única na página que pode nos ajudar para pegar dados do canal como: Título e inscritos.

Como o Youtube utiliza um padrão para endereços canais, então podemos filtrar os dados utilizando o Sed e baixando a página principal do canal que há as informações mais precisas e já armezarmos em variáveis o conteúdo que desejamos, para não poluir nosso ambiente, criaremos novamente arquivos temporários e jogaremos os dados nas variáveis referenciadas.

Leia os comentários no código


# Pega o id do canal e armazena na variável, rodando numa 
subshell id_do_canal=$(cat "$page_video_youtube" | grep 
'channelId' | sed 's/.*\=\"//' | sed 's/\".*//')

# Criamos outro arquivo temporário na pasta /tmp que será nosso 
canal page_canal=$(mktemp)

# Sabemos que o Youtube tem esse padrão, então passamos o ID que
 pegamos e adicionamos ao padrão de url do Youtube
# Fizemos o wget rodar "silenciosamente" jogando a saída para o 
vazio, podemos fazer no anterior também
wget "https://www.youtube.com/channel/$id_do_canal" -O 
"$page_canal" 2>/dev/null


Pronto, já possuímos todos os arquivos que precisamos, logo agora só resta filtrar os conteúdos e armazená-los numa variável para exibirmos numa próxima função que levaremos a ela via array, leia os comentários para entender as linhas, verifique que agora estamos passando a url via parâmetro pra função, pois iremos enviá-la pelo prompt:

function get_dados_youtube() {

# Filtramos o número de inscritos, título do víde, visualizações e gosteis ou não com sed e awk
num_inscritos=$(cat "$page_canal" | grep yt-subscription-button-subscriber-count-branded-horizontal | sed 's/<[^>]*>/ /g' | awk '{print $NF}')
titulo_video=$(cat $page_video_youtube | sed '/title/{p; q;}' | grep title | sed 's/<[^>]*>//g' | uniq | sed 's/...YouTube.*//')
views_video=$(cat $page_video_youtube | grep watch-view-count | sed 's/<[^>]*>//g')
likes=$(cat $page_video_youtube | grep like-button-renderer-like-button-unclicked | sed 's/<[^>]*>//g ;s/ //g')
dislikes=$(cat $page_video_youtube | grep like-button-renderer-dislike-button-unclicked | sed 's/<[^>]*>//g ;s/ //g')

echo "Nome do canal: $titulo_do_canal"
echo "Número de inscritos: $num_inscritos"
echo "Título do vídeo: $titulo_video"
echo "Visualizações: $views_video"
echo "Gosteis: $likes"
echo "Não gosteis: $dislikes"
}

Agora é só criar uma condição que obriga o usuário a informar o vídeo e pronto, veja o script pronto abaixo, copie o código, cole num arquivo, dê permissão de execução e rode:


Shell Script YouTube

No próximo artigo da série vamos adicionar nº de comentários, cores e uma condição para quando não houver URL, nosso script pegar os dados do vídeo mais recente! E depois para finalizarmos essa série, teremos uma surpresinha 😎 !

Se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais?

Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Até a próxima e bons estudos! linha de espaço Fim do texto
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.

Fazendo a pós-instalação do Arch Linux com i3+Polybar+Pywal

Nenhum comentário

sábado, 25 de agosto de 2018

O Arch Linux é uma distro que permite que você customize a instalação de todos os pacotes de software que farão parte do seu sistema, mas por ser, em sua forma padrão, uma distro de configuração bastante manual, é natural "perder tempo" configurando o Arch para deixar ele do seu jeito. No artigo de hoje o nosso amigo Marcos, do canal Terminal Root, vai te dar algumas dicas de pós-instalação do Arch Linux, ideal para quem quer um ambiente minimalista.

Arch Linux - Pós-instalação






O i3 é um Window Manager muito minimalista, mas ele fica melhor quando personalizado. Neste artigo vamos falar sobre ele com a pós-instalação do Arch Linux do i3 (clique aqui para ver um vídeo sobre i3 no Ubuntu Minimal), Polybar, Pywal e mais dos aplicativos listados abaixo de forma Automatizada com Shell Script!

Os pacotes necessários para este tutorial serão:
  • xorg;
  • fonts;
  • lightdm;
  • xterm;
  • firefox;
  • e bash-completion.

Após a instalação do Arch Linux, muitas pessoas perdem muito tempo para deixá-lo pronto pro uso com i3, Polybar e Pywal, nesse caso utilizamos Shell Scripts que automatizam e aceleram todo o processo.

Instalamos o wget, pois ele só existia no CD de boot do Arch . Após baixamos nosso software para pós-instalação automatizada, damos permissão de execução ao programa, verificando quais opções estão disponíveis com o parâmetro --help e otimizamos o espelho de rede, para que as instalações fiquem mais rápidas com o parâmetro --mirror.

Criamos e configuramos um usuário para ser o sudo. E então efetuamos a pós-instalação com nosso aplicativo ninja 😎 !!! Após finalizado, vamos reiniciamos o sistema.

passwd
pacman -Syu
pacman -S wget
wget terminalroot.com.br/pos-arch.in
chmod +x pos-arch.in
./pos-arch.in --help
./pos-arch.in --mirror
./pos-arch.in --sudouser [seu-usuario]
./pos-arch.in --install
reboot

Após iniciar sessão gráfica no i3 , instalamos o Polybar e o Pywal com outro Shell Script Ninja: o Popy
git clone https://gitlab.com/terminalroot/popy.git
cd popy && ./popy.in --all
Além de outras dicas complementares que podem ser consultadas assistindo o vídeo abaixo:


Aprenda a criar aplicativos semelhantes ao pos-arch.in e o popy de forma PROFISSIONAL e EXTREMAMENTE AVANÇADA, se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais? Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Links Úteis

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Não é magia, é Shell Script! Truques da linha de comando Linux

Nenhum comentário

segunda-feira, 20 de agosto de 2018

Dominar o Shell Script é, em outras palavras, automatizar o Linux da forma mais pura. Hoje vamos começar uma série que vai te ajudar a fazer as pazes com o terminal e ainda lhe dar algumas dicas úteis.

Terminal Linux - Shell Script






O Shell Script foi criado por Ken Thompson (Thompson Shell, mais tarde foi substituído pelo Bourne Shell desenvolvido por Stephen BourneBourne Shell), o criador do Unix e Linguagem C, juntamente com Dennis Ritchie. O objetivo principal foi: criar uma forma rápida, fácil e que fosse possível automatizar a comunicação com o Kernel. A principal característica do Shell Script é a mesma que lhe difere de diversas linguagens de programação, que é poder de jogar a saída de um comando para outro comando, o pipe, que atualmente pode ser "invocado" pelo caracter: | .

O Shell Script está presente em todos os sistemas Unix e Unix-like (Linux, FreeBSD, OpenBSD, HP-UX, Solaris, AIX, NetBSD, Irix, etc.), sem dizer que o Microsoft Windows, na sua última versão, possui Shell Script, além do macOS que é um sistema que possui o kernel FreeBSD customizado. Existem diversos tipos de Shell, essa variedade passou a existir por conta das licenças de software. Nas distribuições Linux, o Shell padrão é o Bash (Bourne Again Shell, tratando-se de uma melhoria do Bourne Shell e com uma licença mais permissiva), que é o que utilizaremos aqui.

Customizando a aparência do seu prompt de comando (Variável PS1)


Da mesma forma que existem diversos tipos de Shell, existem também diversos emuladores de terminal para o Shell e diversas formas de apresentar suas características. A primeira coisa que você vê quando abre o terminal é o prompt de comando, para entender melhor ele, podemos dizer que é uma "barra indicadora" da sua posição no Shell. A aparência dele depende diretamente da variável PS1 , que pode ser configurada nos arquivos: ~/.bashrc, .profile ou qualquer arquivo que faça parte da árvore recursiva . Veja na imagem abaixo o exemplo do meu prompt de comando:

Terminal

Ou seja, isso é o conteúdo da minha variável $PS1 . Se você atribuir outro valor a variável PS1 utilizando o próprio Shell, você verá que o prompt será alterado. Exemplo, copie e cole o conteúdo abaixo e cole no seu terminal e depois tecle enter:

PS1=
"blog@diolinux: "

Você notará que o prompt será modificado, mas não se preocupe, se quiser que retorne ao prompt anterior, basta fechar e abrir de novo seu terminal ou rodar o comando abaixo:

source
/etc/profile

Se quiser modificar permanentemente a configuração do seu prompt basta atribuir o valor que deseja no seu .bashrc . Você pode adicionar: sintaxes específicas, cores, caracteres,... Por exemplo, para que seu prompt apresente: o nome de usuário, o nome de seu computador e o diretório em que você se encontra, use essa configuração para seu prompt:
  • \u  - indica o nome de seu usuário;
  • \h  - indica o host;
  • \w  - indica o diretório;
  • \n  - pula para linha abaixo.
E vamos separá-lo por alguns caracteres definidos por nós como: seta,relâmpago e espaços. Ficando assim:
PS1="\u → \h \w\n ⚡"
Abra o arquivo .bashrc com um editor de texto e crie uma nova linha no final do arquivo e insira o conteúdo acima, ou rode o comando abaixo:
echo 'export PS1="\u → \h \w\n ⚡"' >> ~/.bashrc
O comando export serve para deixá-la global!
Se quiser defina cores para sua PS1, usando a seguinte sintaxe: :
  • NUMERO - Corresponde ao número da cor: (31 é vermelho, 32 verde, 33 amarelo, 34 azul, 35 rosa, 36 ciano, 37 branco e 30 preto)
  • TIPO - Define se aparecerá em negrito, sublinhado ou normal: (1 é negrito, 4 sublinhado e 0 normal)
A letra m, logo após o TIPO tem de existir e pode ficar "colada" com o restante do conteúdo. Veja esse exemplo que eu criei para esse artigo:
  • Verde negrito para o nome de usuário: [32;1m
  • Amarelo negrito para a seta: [33;4m
  • Branco normal para o diretório: [37;0m
  • Rosa negrito para o relâmpago: [35;1m
  • E no final desligamos as cores: [m
sh PS1="\e[32;1m\u \e[33;1m→ \e[36;1m\h \e[37;0m\w\n \e[35;1m⚡\e[m"


Terminal customizado

Colorindo o Manual e tornando a leitura mais amigável


O manual do sistema é uma das partes mais acessados pelo Shell, e muita gente não gosta muito de utilizá-lo, pois acha ele técnico demais dizendo que não consegue entender bem. Um dos motivos dessa dificuldade está relacionada ao visual do mesmo. Assim como vimos a dica anterior que incluia utilização de cores, podemos customizar o manual para que ele separe os trechos com cores que FACILITARÃO MUITO nossa leitura. Exemplo: Copie o comando abaixo e cole no final do seu .bashrc e depois abra o manual e veja a diferença:
export LESS_TERMCAP_mb=$'\e[1;32m'
export LESS_TERMCAP_md=$'\e[1;32m'
export LESS_TERMCAP_me=$'\e[0m'
export LESS_TERMCAP_se=$'\e[0m'
export LESS_TERMCAP_so=$'\e[01;33m'
export LESS_TERMCAP_ue=$'\e[0m'
export LESS_TERMCAP_us=$'\e[1;4;31m'

Depois feche e abra o terminal ou rode o comando source ~/.bashrc abra o manual e veja a diferença, ex.: man bash

Manual customizado Linux

Se você ainda não tem muitos conhecimentos em Shell Script e está procurando uma forma eficaz de aprender do zero? Ou quem sabe você já possui conhecimentos em Shell mas quer evoluir e aprender a criar manuais, processos, games, animações, instaladores e muito mais? Então não deixe passar a oportunidade de conhecer o "Curso Extremamente Avançado de Shell Script" que oferecemos junto com a galera do Terminal Root, são 3 cursos pelo preço de um, conheça aqui.

Até a próxima e bons estudos! 
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


O que são GUI e DE? Quais suas diferenças?

Nenhum comentário

terça-feira, 17 de julho de 2018

Uma das dúvidas e confusões de quem está iniciando no mundo Linux: Qual a diferença entre Interface Gráfica e desktop environment? Se você usa Linux há muito tempo e possui essa dúvida, não se sinta mal, o importante é que vamos conferir essa diferença agora mesmo!



A interface gráfica ou GUI (graphical user interface) em um sistema operacional, é uma aplicação, uma das partes do sistema operacional, já o DE (desktop environment), é algo mais abrangente que engloba por exemplo, até mesmo a própria interface gráfica. O desktop environment é composto de várias aplicações e não somente da interface. A interface é uma das aplicações que acompanham o desktop environment e a interface gráfica é basicamente o que você vê na tela do seu sistema operacional.

Podemos usar como exemplo o projeto KDE, que é responsável por gerenciar várias aplicações diferentes, desde aplicações como calculadora, calendário, o nosso querido Kdenlive, utilizado para editar os vídeos do canal e é claro a interface gráfica KDE Plasma, ou somente "Plasma", como os próprios desenvolvedores do KDE convencionaram chamar. Sendo assim, o desktop environment KDE é composto do Plasma juntamente com outras ferramentas desenvolvidas pelo projeto KDE. 

Apesar de usarmos o KDE como exemplo, o mesmo vale para, virtualmente, qualquer outro projeto. Além disso, você pode utilizar uma interface gráfica, mas com aplicações de projetos diferentes. Uma prova disso, é utilizar uma distro como o Linux Mint, com a interface Cinnamon, mas com aplicações GNOME, como o Monitor do Sistema, ou seja, você usa parte de um desktop enviroment em uma distro cujo ambiente gráfico corresponde a outro diferente.

Nesse vídeo no canal, discutimos com vários exemplos a diferença entre interface gráfica e desktop environment no Linux e vale muito a pena conferir.


Espero que este post e vídeo tenham lhe ajudado :)

Até mais!

_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


Matrículas abertas para o curso de SHELL SCRIPT! (TEMPO E VAGAS LIMITADAS)

Nenhum comentário

sábado, 5 de agosto de 2017

Depois de dois meses em hiato, finalmente vamos conseguir abrir as vagas para o curso de Shell Script do Diolinux EAD. Agora o Tiago Salem, nosso professor, estará apto a receber e atender novos alunos.

Curso de Shell Script






Chegou a hora de abrirmos as matrículas para a nossa segunda turma de alunos para o curso "Shell Script - Dominando o Linux uma linha  por vez" ministrado no Diolinux EAD pelo professor Tiago Salem, ex-desenvolvedor da Canonical e atual Engenheiro de Suporte L3 na SUSE.

Assim como fizemos no lançamento da primeira turma, não podemos deixar as matrículas abertas tempo demais e nem deixar as vagas liberadas por conta da agenda do Tiago, que quer dar atenção especial a todos os seus alunos.

Vagas limitadas e tempo limitado


Quando fechamos as matrículas pela primeira vez, colocamos no Diolinux EAD um formulário para que as pessoas pudessem entrar na lista de espera para esta próxima turma, a ideia era fechar uma turma de 50 pessoas no máximo, porém, tivemos uma popularidade incrível e por conta disso vamos abrir 100 vagas, pois 91 pessoas já haviam se candidatado a  uma vaga no curso através deste formulário.

Essas mais de 90 pessoas receberam de antemão em seus e-mails hoje pela manhã o link para compra para garantir as suas vagas. De qualquer forma, as matrículas ficarão abertas somente até o dia 10 de Agosto, depois fecharemos elas novamente por tempo indeterminado, até que tenhamos mais capacidade para atender todo mundo.

Atenção para as pessoas que colocaram seus nomes da lista: O fato do seu nome estar lá não lhe garante uma vaga necessariamente, mas ele te deu uma vantagem em relação aos outros compradores para que você possa comprar ele antes.

Se você quiser dominar o Linux através do Shell Script, a hora é agora!


Como as vagas são limitadas e o tempo também, o melhor momento para você comprar o curso é exatamente agora, corra lá e garanta o seu espaço em um curso extremamente bem elaborado e com um profissional de primeiro nível como instrutor.

Se estiver precisando de "incentivo", nós temos 50 cupons de desconto para serem usados por pessoas que não fizeram o curso de Bash ainda, estes recebem automaticamente um desconto especial para o curso de Shell Script, para comprar o curso de Shell com R$ 49,90 de desconto basta inserir o código a seguir na hora de finalizar a compra:

HWAYTSHELL

Pegou a referência ao AC/DC? 😀

Esperamos você no curso enquanto durarem as vagas, clique aqui para acessar.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.


O que é possível fazer com Shell Script?

Nenhum comentário

sexta-feira, 4 de agosto de 2017

Recentemente um dos alunos lá do EAD do Diolinux fez uma pergunta interessante:  O que é possível de se fazer com shell script? Como esta é uma dúvida muito comum, aqui neste artigo vamos entender melhor o que é possível de se fazer com shell script e quando se deve (ou não) usar shell script.

Curso de Shell Script




A primeira coisa que temos que entender é que as linguagens de programação (e incluo shell script aqui) são ferramentas que nós entusiastas de tecnologia utilizamos para resolver problemas.

Dependendo da natureza do problema, existe uma ferramenta mais adequada.

Explico:

Vamos supor que você precise serrar uma tábua. Você tem a opção de escolher entre um serrote e uma faca de cozinha. Qual você escolheria?


É claro que a ferramenta que vai dar resultado mais rápido e com menos esforço é o serrote.. mas.. se você quisesse usar a faca, também iria funcionar, só que iria exigir *muito* mais esforço e demoraria muito mais tempo.

Com linguagens de programação é a mesma coisa, e por isso que não existe "a melhor linguagem".

Cada uma é boa em fazer uma coisa, e quanto mais você domina a "ferramenta", melhor e mais rápido você resolve os problemas.

Shell Script é uma linguagem que você utiliza para pedir que o Bash automatize diversos tipos de tarefas, especialmente quando estas tarefas envolvem invocar comandos do terminal.

O Bash trabalha muito bem interagindo com comandos da linha de comando (capturando saída de comandos, condicionando execução de comandos, etc), e por isso é a ferramenta preferida de uma enorme quantidade de pessoas para automatizar tarefas principalmente administrativas.


É claro que em outras linguagens também é possível de se obter o mesmo resultado, mas pode talvez não ser tão trivial quando em shell script.

O oposto também é verdadeiro. Já vi gente implementando um servidor web em shell script (tipo um apache ou nginx). É claro que funciona, porém é uma solução que não "escala". Shell script não é uma linguagem de alta performance, e portanto este servidor web, apesar de ser um ótimo exercício para fins didáticos, não poderia ser utilizado "para valer" devido ao seu desempenho ruim comparado a um servidor escrito em C ou C++.


Outro exemplo é um projeto muito bacana: Mario em shell script.

Simplesmente sensacional e mostra todo o poder do shell script, mas evidentemente não é a ferramenta ideal para se escrever um jogo.

Resumo da obra:

O poder está na mão do programador em decidir qual é a ferramenta mais adequada para se resolver algum problema, e se este problema envolve automatização de comandos disponíveis no terminal e tarefas administrativas, não precisa pensar duas vezes e pode mandar bala no shell script.

E por falar nisso, se você já tem experiência na linha de comando e gostaria de passar para o próximo nível, entender como o processo de criação de um script funciona e entender os diversos operadores e estruturas que o bash fornece para automatizar processos, em breve abriremos mais vagas no curso de shell script lá no EAD do Diolinux.

Existe uma fila de espera para os cursos, são 100 vagas que serão abertas, até o momento temos 84 inscritos, então se você tem interesse, corre lá para ver!

Este texto foi escrito pelo Tiago Salem, nosso professor no Diolinux EAD.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Como criar um Shell Script simples para automatizar a instalação de programas no Linux

Nenhum comentário

terça-feira, 13 de junho de 2017

Uma das coisas mais legais do Bash é o poder de automatizar tarefas, até mesmo na própria linha de comando. Hoje você vai aprender a criar um simples Shell Script para instalar um programa.

Shell Script




Para você entender o conceito, vamos dar um exemplo com um programa popular e simples, o GIMP. O GIMP é um manipulador de imagens que está no repositório de todas as distros Linux praticamente, como exemplo nos comandos vamos usar o gerenciador de pacotes "apt", comum no Debian, Ubuntu, Linux Mint e derivados, apesar disso, entendendo o conceito, você pode aplicar em qualquer distro, basta entender o gerenciador de pacotes dela e os comandos que ele aceita.

Claro, o GIMP pode ser instalado por centrais de apps sem comandos, pode ser também instalado com um simples # apt install gimp mas a intenção é te mostrar como você pode estruturar um script para automatizar a instalação de qualquer programa ou de vários ao mesmo tempo.

Vamos imaginar que você queria instalar o gimp a partir do terminal.

Muito provavelmente os passos que você dará serão:

1) Atualizar os repositórios
$ sudo apt-get update
2) Instalar possíveis atualizações do sistema:
$ sudo apt-get dist-upgrade -y
3) Efetivamente instalar o pacote.
$ sudo apt-get install gimp

O processo manual da instalação de um programa pode levar algum tempo, pois você deverá esperar que o primeiro comando termine sua execução para digitar o próximo.

Nem sempre atualizar repositórios é rápido e portanto é o seu tempo que está sendo gasto esperando algo que poderia facilmente ser automatizado.

O primeiro nível de automatização que poderíamos fazer aqui é criar uma fila de comandos (chamadas de listas) que serão executados pelo Bash em sequência.

Para isso basta separar os comandos com um ponto e vírgula:
sudo apt-get update ; sudo apt-get dist-upgrade -y ; sudo apt-get install gimp -y
Apesar de já automatizar um pouco o processo, não há praticamente nenhuma lógica envolvida.

Você muito provavelmente não deseja executar um "dist-upgrade" se o "update" falhar antes por qualquer motivo. Certo?

Aqui chegamos no nosso segundo nível de automatização. Em vez de usar o ponto e vírgula, podemos separar os comandos com "&&", e desta forma o Bash somente executará o comando seguinte se o anterior finalizar a execução com sucesso.
sudo apt-get update && sudo apt-get dist-upgrade -y && sudo apt-get install gimp -y
Agora já melhoramos bastante o processo, porém no caso de algum dos comandos retornar falha, esta fila de comandos simplesmente para de ser executada sem qualquer tipo de aviso mais elaborado para o usuário.

É possível em linha de comando adicionar mais lógica para continuar aperfeiçoando este nosso procedimento, porém este é aquele momento em que talvez seja mais proveitoso se criar um script de verdade e deixar o processo legível, em vez de simplesmente criar uma "tripa" de comandos que depois poderá dificultar a sua vida na hora de encontrar e consertar qualquer erro.

Para este nosso exemplo, usaremos o próprio "if" do Bash (que é uma estrutura de condicional explicada brevemente neste vídeo aqui)

Basta criar um arquivo de texto que você pode 'chamar do que quiser .sh", tipo "batatinha_quando_nasce.sh" e inserir os dados que vamos te mostrar. Tá bom, talvez seja melhor criar um arquivo chamado instala-pacote.sh o seguinte conteúdo:

#!/bin/bash

echo Atualizando repositórios..
if ! apt-get update
then
    echo "Não foi possível atualizar os repositórios. Verifique seu arquivo /etc/apt/sources.list"
    exit 1
fi
echo "Atualização feita com sucesso"

echo "Atualizando pacotes já instalados"
if ! apt-get dist-upgrade -y
then
    echo "Não foi possível atualizar pacotes."
    exit 1
fi
echo "Atualização de pacotes feita com sucesso"

# note que $1 aqui será substituído pelo Bash pelo primeiro argumento passado em linha de comando
if ! apt-get install $1
then
    echo "Não foi possível instalar o pacote $1"
    exit 1
fi
echo "Instalação finalizada"

Veja que utilizamos o operador "!" após o "if" para inverter o resultado do comando seguinte, portanto o conteúdo das condicionais (código que está entre o "then" e o "fi") somente será executado caso os comandos falhem na execução. Também utilizamos o comando "exit 1" para pedir ao Bash que interrompa a execução do script em caso de falha.

Para executar o script basta rodar a seguinte linha:

sudo bash instala-pacote.sh gimp

Desta forma podemos utilizar o mesmo script para qualquer pacote, e o "sudo" só precisa ser invocado uma vez. Basta passar o nome do pacote desejado em linha de comando e ver o Bash fazer o resto sozinho.

É possível melhorar e incrementar o script de diversas maneiras. Podemos imprimir mensagens com cores, suprimir a saída em tela do comando apt-get para facilitar a leitura, dentre outras coisas.

Basta ter criatividade e dominar a linguagem do shell script para poder automatizar praticamente o que você quiser.


Outra coisa que você pode fazer é incluir dentro do Shell Script os comandos para a instalação do pacote em específico, assim você pode rodar apenas o Shell Script e ele se encarrega de fazer a instalação para você.

Você pode por exemplo criar um script de pós formatação para o seu sistema, acrescentando repositórios, pacotes e programas que você normalmente usa, incluindo as opções para fazer a atualização do sistema e apenas rodar um Shell Script depois de instalar a sua distro e ir tomar café enquanto seu sistema é montando automaticamente. É mais do que bacana!

Nós lançamos nesta semana o nosso curso avançado de Shell Script, onde você vai aprender coisas como esta deste post e muitas outras para automatizar a sua vida de usuário Linux, as matrículas estão abertas até Quinta-feira, dia 15 de Junho e tem promoção especial para quem comprar hoje até a meia-noite. Corre lá pra conferir antes que fechem as matrículas.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




5 motivos para se aprender Shell Script e dominar o Linux

Nenhum comentário

quarta-feira, 7 de junho de 2017

Não dá para negar que o Bash é um dos interpretadores de comando mais utilizados no mundo.
E não é a toa. Às vezes é impossível ver o potencial escondido atrás da linha de comando do Bash a olho nú.

Shell Script



Basta abrir a man page do Bash para ver o mundo de possibilidades (e até se impressionar/amedrontar um pouco).

Se você já fez o nosso curso de terminal, você já teve uma pequena amostra da quantidade de coisas que dá pra fazer na linha de comando (modo interativo).

Porém, muito se engana quem acha que shell scripts só servem para automatizar backups e afins.

Abaixo vamos listar 5 motivos para se aprender a arte do shell scripting.

1 - Inúmeras partes de uma distribuição linux utilizam shell scripts.

Shell Script


- Sistemas de empacotamento (rpm e deb): scripts são usados na hora de criar pacotes, e até na hora de instalar (scripts pós instalação).

- Init systems (upstart, sysvinit): precisam de shell scripts para controlar serviços que rodam aí por debaixo dos panos.

- Grub: Arquivos que geram configurações do boot são shell scripts: /etc/grub.d/

- startx: famoso comando que inicia modo gráfico é um shell script.

- xdg-open: comando para abrir arquivos automaticamente no programa correto, também é um shell script.

Poderíamos passar horas aqui listando lugares e sub-sistemas de uma distribuição linux que usam shell scripts.

2 - Novos conceitos, mas os Shell Scripts estão lá

Shell Scripts em drones?


É impressionante como o tempo passa, as tecnologias evoluem, os conceitos de computação mudam, porém shell scripts sempre aparecem em algum canto.

Talvez você tenha percebido que o que mais se fala hoje em dia é sobre computação em nuvem.
Demanda por novos profissionais que entendam de diversas tecnologias diferentes surgem, como docker e openstack.

E apesar dos conceitos novos, ainda lá na base o shell script continua firme e forte.

- Docker: Dentro do arquivo que define um container docker você pode utilizar shell scripts.

- Openstack: Você pode executar um script no primeiro boot de uma máquina virtual para personalização.

3 - Entender Shell Scripts melhora seu conhecimento no modo interativo

Aprendendo Shell Script


O Bash pode ser executado em basicamente dois modos: interativo (linha de comando) e não interativo (scripts).

Uma das coisas mais fascinantes do mundo dos interpretadores de comandos é o número de formas diferentes para se executar uma mesma tarefa.

Muitas pessoas passam muitos anos com um canivete suíço nas mãos, porém tentam fazer tudo somente utilizando a faca mais simples do canivete, pois é a única que sabem abrir.

Este canivete é o Bash. Quando nos aprofundamos em scripts e entendemos suas estruturas para controle de fluxo, variáveis, etc, conseguimos otimizar muito nosso tempo. Estruturas como o "for", e até mesmo funções, que geralmente são encontradas somente em scripts, podem facilmente
ser utilizadas direto na linha de comando em modo interativo. E é aí que está o pulo do gato.

Tarefas como renomear vários arquivos de um diretório de uma só vez podem facilmente ser feitas com uma linha como a seguinte:

for i in *.txt; do mv $i ${i%%.txt}-old.txt; done # renomeia todos os arquivos .txt para arquivo-old.txt

4 - Melhorar seu currículo

Currículo Shell Script


Qualquer pessoa que deseje trabalhar profissionalmente com Linux, ou seja, fazer do seu hobby uma profissão de verdade, precisa necessariamente dominar shell scripts. Independente da área que você planeje atuar (programação, administração de redes, administração de sistemas) você precisará escrever e ler scripts de outras pessoas.

Há ofertas de emprego que hoje em dia nem mesmo mencionam a exigência de saber shell scripts pois já assumem que o candidato sabe.

5 - Shell script é divertido

Shell Script é divertido


Somente amantes de tecnologia irão entender este motivo. Mas sim, o prazer de automatizar tarefas e ver aquele script que você criou do zero funcionando sozinho e ficar orgulhoso de ver ele fazendo aquilo que antigamente você precisava fazer "na mão"... este sentimento inexplicável já é motivo suficiente para largar tudo o que você está fazendo e ir correndo aprender shell scripts.

Claro que há muito material da internet para você pesquisar, apostilas e tudo mais, mas como vocês pediram diversas vezes, nós vamos lançar um novo curso no EAD.

Se você não tem ideia por onde começar e precisa de um guia, fique ligado que em breve lá no EAD do Diolinux será lançado um curso completo de Shell Script. Mais de 11 horas de vídeo aulas explicando detalhadamente tudo o que você precisa saber para dominar a arte automatizar tarefas
e otimizar a sua vida na linha de comando.

Este artigo foi escrito em parceria com o nosso professor Tiago Salem, ele já possui um curso de Bash (Terminal) lá no Diolinux EAD, esse curso é quase que um pré-requisito para o de Shell que está por vir, vale a pena dar uma olhada.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Explainshell - Entenda o que cada comando do Linux faz

Nenhum comentário

quinta-feira, 19 de maio de 2016

A dica de hoje é especial para quem está começando a dar os seus primeiros passos no terminal Linux. É muito comum você estar buscando conteúdo, soluções para problemas na internet e se deparar com comandos que você não sabe exatamente o que fazem, é justamente para isso que o Explainshell serve, te explicar cada um deles.

explainshell



Para usar a ferramenta é muito simples, acesse o site explainshell.com e cole no campo de busca o comando que você deseja que seja explicado para você e pressione "enter", ao fazer isso, cada sessão do comando receberá uma explicação logo abaixo.

O site é em inglês, você pode considerar aprender inglês, pelo menos um instrumental básico para informática ou utilizar ama ferramenta de tradução ao seu gosto, como o Google Tradutor por exemplo. Assim você vai aprendendo aos poucos para quê cada comando serve. Muito legal né?

Publicidade

Quem estiver interessado em ampliar seus conhecimentos sobre Shell Script pode dar uma olhada no livro "Shell Linux - Do aprendiz ao administrador" disponível na nossa loja, a DioStore.

Livro sobre Shell Script na DioStore

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Testando pen drives bootáveis no VirtualBox

Nenhum comentário

sexta-feira, 7 de agosto de 2015

Um script para facilitar o teste de pen drives bootáveis de qualquer sistema operacional em uma máquina virtual do VirtualBox.

Testando pen drives no VirtualBox

Verificando se o pen drive está dando boot corretamente


Recebi ontem por e-mail um Shell Script feito pelo nosso leitor Marcelo Klumpp que permite que o usuário teste um pen drive bootável que foi criado com qualquer programa, como o Unetbootin por exemplo, em uma janela do VirtualBox, desta forma você não precisa reiniciar o computador para testar o recurso.

Segue o texto recebido

Eu criei um script (2 na verdade, mas são singulares, vai entender o porquê) para facilitar num teste de boot de um dispositivo USB.

Peguei algumas informações na internet e aprendí como fazer para acessar um Boot USB via Virtual Box, levando em conta que o mesmo não tem suporte a boot via USB ou dispositivo físico diretamente, apenas via CDRom, Floppy, etc.

Fiz alguns testes de boot via qemu e percebí que o teste de Boot nele chega a ser MUITO pesado, e eu não uso o VMWare. O mesmo Boot funciona de forma BEM leve no Virtual Box, então foi aí que tive a idéia de criar um Bash Script simples pra testar um device diretamente no Virtual Box, pois eu tenho de trampar direto com isto.

São 2 Scripts idênticos, a única coisa que muda é que um é pra ser executado como Máquina Virtual de 32 bits e outro como Máquina Virtual 64 bits:

VirtualBox-BootUSB
VirtualBox-BootUSB_64

O parãmetro é ligeiramente fácil:

VirtualBox-BootUSB -d /dev/sdX -p NP -m QM

Sintase:

-d = Device
/dev/sdX = O Device a ser indicado
-p = Partição
NP = Número da Partição a ser indicada
-m = Memória
QM = Quantia de memória (em Mega) escolhida para funcionar na Máquina Virtual

Se esquecer como que faz o comando é só digitar o parâmetro "--help" ou "-h"

Com isto basta fazer o comando "sudo fdisk -l" ou "sudo blkid" e ver qual é o dispositivo que quer testar.

Exemplo:

Dou um destes comandos e vejo que o que quero testar é o "/dev/sde1" e é um boot de uma instalação de sistema que usa 250 MB Ram, então eu faço o comando:

VirtualBox-BootUSB -d /dev/sde -p 1 -m 250

O comando irá pedir a senha do sudo, então é só digitar a senha e o comando faz o resto.

Exemplo do Shell Script


Pronto, bem fácil e bom pra quando a gente cria um Boot Inicializável mas não deseja ou não pode testar o mesmo na própria máquina tendo de reiniciar.

Já peguei instalador que nem pergunta se eu quero particionar ou etc, já vai escrevendo no HD e pronto, desta forma fica perigoso testar na própria máquina e ter o risco de perder seus dados. 

Também é chato quando se está criando um boot e tem de ir testando se dá certo e tem de reiniciar toda hora. Então este Script se torna bem útil.

Baixe o Script


Você pode baixar o script do nosso leitor logo abaixo:

Se você tiver alguma sugestão a fazer para melhorar o script é possível entrar em contato com o autor através deste e-mail: elppansmk@gmail.com

Agradecemos ao leitor por compartilhar o seu projeto conosco, se você tiver também algum projeto bacana e gostaria de compartilhar com a comunidade manda um e-mail pra gente!

Edital: O conteúdo deste script não é produção do blog Diolinux.

Até a próxima!
_____________________________________________________________________________
Viu algum erro ou gostaria de adicionar alguma sugestão a essa matéria? Colabore, clique aqui.




Blog Diolinux © all rights reserved
made with by templateszoo