├── .gitignore
├── img
├── casa.png
├── noip.png
├── php.png
├── vim.png
├── docker.png
├── mysql.png
├── social.png
├── tomcat.png
├── noip-host.png
├── phpinfo.png
├── serverweb.png
├── phpmyadmin.png
├── postgresql.png
├── vtp_ifsp-pb.png
├── DockerImages.jpg
├── apache-logo-3.png
├── birazn-social.png
├── dockerhub-tela.png
├── seta-para-tras.png
├── LAMP-Stack-logo.png
├── phpmyadmin-hide.png
├── seta-para-frente.png
├── dockerhub-repositorio.png
└── virtual_hosts_diagram.jpg
├── LICENSE
├── Aulas
├── 01-Editor_Texto.md
├── 02-ServidorWeb.md
├── 010-Dicas_Basica_Docker.md
├── 011-Primeiro_Dockerfile.md
├── 010-Gerenciando_container.md
├── 09-Docker_LinuxMint_21.md
├── 06-PostgreSQL.md
├── 07-DNS_Dinâmico_NOIP.md
├── 03-VirtualHosts.md
├── 012-Subindo_imagem_para_DockerHub.md
├── 05-Paginas_Pessoais.md
├── 04-LAMP.md
└── 08-Iniciando_com_Docker.md
└── README.md
/.gitignore:
--------------------------------------------------------------------------------
1 |
2 | *.backup
3 |
--------------------------------------------------------------------------------
/img/casa.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/casa.png
--------------------------------------------------------------------------------
/img/noip.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/noip.png
--------------------------------------------------------------------------------
/img/php.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/php.png
--------------------------------------------------------------------------------
/img/vim.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/vim.png
--------------------------------------------------------------------------------
/img/docker.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/docker.png
--------------------------------------------------------------------------------
/img/mysql.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/mysql.png
--------------------------------------------------------------------------------
/img/social.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/social.png
--------------------------------------------------------------------------------
/img/tomcat.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/tomcat.png
--------------------------------------------------------------------------------
/img/noip-host.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/noip-host.png
--------------------------------------------------------------------------------
/img/phpinfo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/phpinfo.png
--------------------------------------------------------------------------------
/img/serverweb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/serverweb.png
--------------------------------------------------------------------------------
/img/phpmyadmin.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/phpmyadmin.png
--------------------------------------------------------------------------------
/img/postgresql.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/postgresql.png
--------------------------------------------------------------------------------
/img/vtp_ifsp-pb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/vtp_ifsp-pb.png
--------------------------------------------------------------------------------
/img/DockerImages.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/DockerImages.jpg
--------------------------------------------------------------------------------
/img/apache-logo-3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/apache-logo-3.png
--------------------------------------------------------------------------------
/img/birazn-social.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/birazn-social.png
--------------------------------------------------------------------------------
/img/dockerhub-tela.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/dockerhub-tela.png
--------------------------------------------------------------------------------
/img/seta-para-tras.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/seta-para-tras.png
--------------------------------------------------------------------------------
/img/LAMP-Stack-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/LAMP-Stack-logo.png
--------------------------------------------------------------------------------
/img/phpmyadmin-hide.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/phpmyadmin-hide.png
--------------------------------------------------------------------------------
/img/seta-para-frente.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/seta-para-frente.png
--------------------------------------------------------------------------------
/img/dockerhub-repositorio.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/dockerhub-repositorio.png
--------------------------------------------------------------------------------
/img/virtual_hosts_diagram.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/birazn/IDS-IFSPVTP/HEAD/img/virtual_hosts_diagram.jpg
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2020 Ubiratan Zakaib do Nascimento
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/Aulas/01-Editor_Texto.md:
--------------------------------------------------------------------------------
1 |
2 | # Editor de Texto - Configuração 
3 |
4 | 
5 |
6 | Vim, é uma opção ao editor em modo texto nano que tem as bases do Vi com algumas atualizações.
7 |
8 | Para instalar:
9 |
10 | ```shell
11 | sudo apt install vim # Geralmente já vem instalado nas versões atuais do Ubuntu
12 | sudo vim /etc/vim/vimrc # O vimrc é o arquivo que tem as configurações do vim
13 | ```
14 |
15 | Descomentar as linhas, caso seja necessário:
16 |
17 | ```shell
18 | # Procurar esta linha
19 | if has("syntax")
20 | syntax on
21 | endif
22 |
23 | # Procurar esta linha e descomente, dependendo do tema do seu terminal
24 | set background=dark
25 |
26 | # Procurar esta linha
27 | au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g'\"" | endif
28 |
29 | # Procurar esta linha
30 | filetype plugin indent on
31 |
32 | # Incluir essas linhas logo apos os 'set'
33 | set nu
34 | set cursorline
35 | ```
36 |
37 |
38 | 
39 |
40 | Servidor Web
41 |
42 |
43 |
44 |
45 | 
46 |
47 | Sumário
48 |
49 |
50 |
51 | ---
52 | ## Dúvidas?
53 |
54 | [@birazn](https://www.instagram.com/birazn)
55 |
56 | [Canal YouTube](https://www.youtube.com/birazn)
57 |
58 | 
--------------------------------------------------------------------------------
/Aulas/02-ServidorWeb.md:
--------------------------------------------------------------------------------
1 | # Servidor Web – Habilitando a Navegação
2 |
3 | 
4 |
5 | # O que é?
6 |
7 | Servidor web pode ser um programa de computador responsável por aceitar pedidos HTTP de clientes, geralmente os navegadores, e servi-los com respostas HTTP, incluindo opcionalmente dados, que geralmente são páginas web, tais como documentos HTML com objetos multimídias embutidos.
8 |
9 | O mais popular, e mais utilizado no mundo, é o servidor **Apache** (software livre).
10 |
11 | A Microsoft possui a sua própria solução denominada **IIS** (Internet Information Services).
12 |
13 | 
14 |
15 | ## Instalando e Configurando Apache 2
16 |
17 | #### O Servidor Apache ou Servidor HTTP Apache.
18 |
19 | Antes de qualquer instalação é aconselhável verificar por atualizações nos repositórios.
20 |
21 | ```shell
22 | sudo apt update
23 | sudo apt upgrade
24 | sudo apt install apache2
25 | ```
26 |
27 | ## Configurando Apache 2
28 |
29 | Para fazer configurações mais finas dentro do apache, o arquivo utilizado é:
30 |
31 | ```shell
32 | sudo vim /etc/apache2/apache2.conf
33 | ```
34 |
35 |
36 |
37 |
38 |
39 | Virtual Hosts
40 |
41 |
42 |
43 |
44 |
45 |
46 | Sumário
47 |
48 |
49 |
50 | ---
51 | ## Dúvidas?
52 |
53 | [@birazn](https://www.instagram.com/birazn)
54 |
55 | [Canal YouTube](https://www.youtube.com/birazn)
56 |
57 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## IDS-IFSPVTP 
2 | # Implantação de Servidores
3 | Repositório focado em disponibilizar materiais sobre a disciplina de Implantação para os Cursos Analise e Desenvolvimento de Sistemas(descontinuado) e Bacharel em Sistemas de Informação do Instituto Federal de São Paulo, Campus Votuporanga.
4 |
5 | Professor responsável: Ubiratan Zakaib do Nascimento
6 |
7 | Instagram: [@birazn](https://www.instagram.com/birazn)
8 |
9 | # Sumário
10 |
11 | ## Instalando manualmente - Conceitos básicos
12 | - [Editor de Texto](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/01-Editor_Texto.md)
13 | - [Servidor Web - Apache](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/02-ServidorWeb.md)
14 | - [VirtualHosts](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/03-VirtualHosts.md)
15 | - [LAMP](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/04-LAMP.md)
16 | - [Páginas Pessoais](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/05-Paginas_Pessoais.md)
17 | - [PostgreSQL](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/06-PostgreSQL.md)
18 | - [NOIP - DNS Dinâmico](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/07-DNS_Dinâmico_NOIP.md)
19 |
20 | ## Iniciando com Docker - Conceitos básicos
21 | - [Docker básico](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/08-Iniciando_com_Docker.md)
22 | - [Docker no Linux Mint](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/09-Docker_LinuxMint_21.md)
23 | - [Dicas Basicas sobre Docker](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/010-Dicas_Basica_Docker.md)
24 | - [Gerenciando Container](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/010-Gerenciando_container.md)
25 | - [Primeiro Dockerfile](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/011-Primeiro_Dockerfile.md)
26 | - [Subindo imagem Docker hub](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/012-Subindo_imagem_para_DockerHub.md)
27 | - [Docker compose - exemplo](https://github.com/birazn/compose-exemplo)
28 |
29 |
30 |
31 |
32 | ---
33 |
34 | ## Dúvidas?
35 |
36 | [@birazn](https://www.instagram.com/birazn)
37 |
38 | [Canal YouTube](https://www.youtube.com/birazn)
39 |
40 | 
--------------------------------------------------------------------------------
/Aulas/010-Dicas_Basica_Docker.md:
--------------------------------------------------------------------------------
1 | # Dicas Básicas sobre Docker 
2 |
3 |
4 |
5 | ## Criando Instância e configurando
6 |
7 |
8 | - **Crie normalmente a instância, conforme as aulas anteriores, liberando já durante a configuração as portas 22 e 80;**
9 | - **Após ter conectado na instância, precisamos fazer a instalação da *Engine Docker*, para isso existem várias formas, vou deixar aqui, a que julgo mais simples para distros raiz;**
10 | - **Faça primeiramente a instalação do CURL;**
11 | - **Se já estiver, irá receber a mensagem ao executar o comando de instalação;**
12 |
13 | ```bash
14 | sudo apt update && sudo apt upgrade -y
15 | sudo apt install curl
16 | ```
17 |
18 | ### **Pegar o *script* e executar em Terminal Bash**
19 |
20 | ```bash
21 | # Pegar o script e executar em Bash
22 | curl -fsSL https://get.docker.com | bash
23 |
24 | # Colocando usuario no grupo do Docker - É necessario reiniciar a sessão ou a Instância
25 | sudo usermod -aG docker ubuntu
26 |
27 | # Testando a versão do Docker
28 | sudo docker version
29 |
30 | # Testando a versão do Docker Compose
31 | sudo docker compose version
32 |
33 | # Verificando Containers em Execução
34 | docker container ls
35 | ```
36 |
37 | ## A linha de comando Docker CLI segue uma dinâmica após a última atualização.
38 |
39 | **docker {objeto} {ação} {parâmetros}**
40 |
41 | **docker {container | image | network | volume | ...} {run | ls | inspect | rm | create | ...}**
42 |
43 | ```bash
44 | # Baixando a imagem do alpine
45 | docker image pull alpine:3.20
46 |
47 | # Listando as imagens baixadas
48 | docker image ls
49 |
50 | # Rodando um container com a imagem baixada
51 | docker container run -it alpine:3.20 sh
52 |
53 | # É possivel fazer tudo de uma vez só, baixando e executando
54 | docker container run -it hello-world
55 | docker container run -it ubuntu
56 | ```
57 |
58 | ### **Para sair de um container, sem o finalizar “matar”, use a combinação de teclas CTRL+P+Q**
59 |
60 | *O ENTRYPOINT* é o principal comando a ser executado quando o container sobe. Ele deve ser, inclusive, um comando que prende o terminal, caso contrário o container apenas sobe e desce não se mantendo útil. Esse comando deve receber um array ou mesmo um parâmetro único.
61 |
62 | ## Outros exemplos de utilização
63 |
64 | > [!TIP]
65 | >
66 | > #### docker container **attach** [CONTAINER ID]
67 | > #### docker container **rm** [CONTAINER ID]
68 | > #### docker container [**start/stop/restart**] [CONTAINER ID]
69 | > #### docker container **inspect** [CONTAINER ID]
70 | > #### docker container **pause** [CONTAINER ID]
71 | > #### docker container **unpause** [CONTAINER ID]
72 | > #### docker container **stats** [CONTAINER ID]
73 | >
74 |
--------------------------------------------------------------------------------
/Aulas/011-Primeiro_Dockerfile.md:
--------------------------------------------------------------------------------
1 | # Primeiro Dockerfile
2 |
3 |
4 |
5 |
6 |
7 | Até agora tudo foi feito na linha de comando, porém, principalmente nos dias de hoje, não dá para viver mais sem automatizar as coisas, então vamos conhecer o Dockerfile.
8 |
9 | O *dockerfile* nada mais é do que um arquivo onde você determina todos os detalhes do seu *container*, como, por exemplo, a imagem que você vai utilizar, aplicativos que necessitam ser instalados, comandos a serem executados, os volumes que serão montados e assim por diante.
10 |
11 | Nosso primeiro Dockerfile.
12 |
13 | ```bash
14 | mkdir primeiroDockerfile
15 | cd primeiroDockerfile
16 | vim Dockerfile
17 | ```
18 |
19 | Com o arquivo aberto para edição, escrevam as linhas que seguem.
20 |
21 | ```Dockerfile
22 | FROM debian
23 | RUN /bin/echo "OLA DOCKER"
24 | ```
25 |
26 | Salve e sai do editor de texto vim.
27 |
28 | Após a criação do arquivo é necessária criação dessa imagem.
29 |
30 | ```bash
31 | docker build -t nome-imagem:1.0 .
32 | ```
33 |
34 | O ponto "**.**" do final do comando, indica que o Dockerfile a ser executado é o que está na própria pasta que estamos.
35 |
36 | Após a execução, verifique se a imagem foi criada
37 |
38 | ```bash
39 | docker image ls
40 | ```
41 |
42 | ## Criando algo útil
43 |
44 | Vamos agora criar uma imagem que traga um Apache funcionando dentro de um Ubuntu, expondo a porta **80** do *container* e colocando o apache em execução.
45 |
46 | ```dockerfile
47 | FROM ubuntu
48 | LABEL maintainer="@birazn"
49 | RUN apt update
50 | RUN apt install apache2 -y
51 | RUN apt autoclean
52 |
53 | EXPOSE 80
54 | CMD ["apache2ctl", "-D", "FOREGROUND"]
55 | ```
56 |
57 | Após a criação do arquivo é necessária criação dessa imagem.
58 |
59 | ```bash
60 | docker build -t serverweb:1.0 .
61 | ```
62 |
63 | > #### Lembrando que cada Dockerfile deve estar dentro de seu diretório
64 |
65 | Feita a imagem é possivel executar normalmente como vinhamos fazendo com as imagens externas.
66 |
67 | ```bash
68 | docker container run --name MeuServidor -d serverweb:1.0
69 | ```
70 |
71 |
72 |
73 | ---
74 |
75 |
76 |
77 |
78 | Proximo
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 | Sumário
87 |
88 |
89 |
90 | ---
91 |
92 | ## Dúvidas?
93 |
94 | [@birazn](https://www.instagram.com/birazn)
95 |
96 | [Canal YouTube](https://www.youtube.com/birazn)
97 |
98 |
--------------------------------------------------------------------------------
/Aulas/010-Gerenciando_container.md:
--------------------------------------------------------------------------------
1 | # Gerenciando *container*
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | ## Recursos básicos de hardware
10 |
11 | Como vimos o parâmetro `stats` mostra informações dos *container* em execução, se em alguma necessidade seja importante limitar os recursos é possível fazer conforme o exemplo.
12 |
13 | ```bash
14 | docker container run --name teste --cpus=4 -m 512m -d nginx
15 | ```
16 |
17 | Desta forma limitamos o uso de CPU em 4 e uso de memora em 512MB. Caso queira alterar estes valores, é possível fazer usando comando `update`
18 |
19 | ```bash
20 | docker container update --cpus=2 -m 256m teste
21 | ```
22 |
23 | ## Recursos de mapeamento de portas
24 |
25 | Em alguns casos é necessário direcionar as requisições da máquina real para dentro do *container*, conforme exemplo.
26 |
27 | ```bash
28 | docker container run --name apache2-container -p 8080:80 -d ubuntu/apache2
29 | ```
30 |
31 | Desta forma, toda requisição feita na por **8080** do navegador local, será redirecionado para porta **80** do *container*, neste caso respondendo com pagina padrão do Apache.
32 |
33 | ## Recursos de mapeamento de diretórios
34 |
35 | Há também a possibilidade de espelharmos uma pasta local, diretamente para dentro do *container*, sendo possível executar nossos arquivos de códigos em interpretadores que estão dentro do *container*. Este mapeamento pode ocorrer usando o caminho absoluto do diretório ou utilizando variável de ambiente do **Docker**.
36 |
37 | ```bash
38 | docker container run --name apache2-volume -v $PWD:/var/www/html -d ubuntu/apache2
39 | ```
40 |
41 | Assim, todo conteúdo da pasta local em que foi executado o `run` será mapeada para a pasta `/var/www/html`
42 |
43 | Unindo os dois comandos, de portas e diretórios temos.
44 |
45 | ```bash
46 | docker container run --name apache2-server -p 8080:80 -v $PWD:/var/www/html -d ubuntu/apache2
47 | ```
48 |
49 | Aqui temos a pasta local sendo mapeada para dentro do *container* em execução e respondendo na máquina local pela porta **8080**.
50 |
51 | ### Agora é só soltar a imaginação, criando infraestruturas com as possibilidades citadas.
52 | ---
53 |
54 |
55 |
56 |
57 | Primeiro Dockerfile
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 | Sumário
66 |
67 |
68 |
69 | ---
70 |
71 | ## Dúvidas?
72 |
73 | [@birazn](https://www.instagram.com/birazn)
74 |
75 | [Canal YouTube](https://www.youtube.com/birazn)
76 |
77 |
--------------------------------------------------------------------------------
/Aulas/09-Docker_LinuxMint_21.md:
--------------------------------------------------------------------------------
1 | # Instalando Docker Linux Mint 21
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 | ## Instalando Docker Engine - Terminal
10 |
11 | ```bash
12 | sudo apt update && sudo apt upgrade -y
13 | sudo apt -y install apt-transport-https ca-certificates curl software-properties-common
14 | ```
15 |
16 | ### Confirmar que não há nada
17 | ```bash
18 | sudo apt -y remove docker docker.io containerd runc
19 | ```
20 |
21 | ### Buscar chave autenticação
22 | ```bash
23 | curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
24 | ```
25 |
26 | ### Adicionar Repositório [Verificar os-release]
27 | ```bash
28 | echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu jammy stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
29 | ```
30 |
31 | ### Testar se deu certo
32 | ```bash
33 | cat /etc/apt/sources.list.d/docker.list
34 | ```
35 |
36 | **Resposta correta**
37 |
38 | ```bash
39 | deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu jammy stable
40 | ```
41 |
42 | ### Verificar se está tudo correto
43 | ```bash
44 | sudo apt update
45 | ```
46 |
47 | ### Instalar recursos para Docker Engine [Não é Docker Desktop]
48 | ```bash
49 | sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
50 | ```
51 |
52 | ### Adicionar seu usuário no grupo docker
53 | ```bash
54 | sudo usermod -aG docker $USER
55 | ```
56 | ***Reinicie a sessão para efetivar mudança***
57 |
58 | ### Verificar versão
59 | ```bash
60 | docker version
61 | ```
62 |
63 | ### Testar primeiro *container*
64 | ```bash
65 | docker run hello-world
66 | ```
67 |
68 | ### Testar algo mais funcional
69 | ```bash
70 | docker container run -it alpine sh
71 | ```
72 |
73 |
74 | ## Fonte
75 | [Computing For Geeks](https://computingforgeeks.com/install-docker-docker-compose-on-linux-mint/)
76 |
77 | ---
78 |
79 |
80 |
81 |
82 |
83 | Gerenciando Container
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 | Sumário
92 |
93 |
94 |
95 | ---
96 |
97 | ## Dúvidas?
98 |
99 | [@birazn](https://www.instagram.com/birazn)
100 |
101 | [Canal YouTube](https://www.youtube.com/birazn)
102 |
103 |
--------------------------------------------------------------------------------
/Aulas/06-PostgreSQL.md:
--------------------------------------------------------------------------------
1 | # PostgreSQL
2 |
3 | ## Instalando e Configurando
4 |
5 |
6 |
7 |
8 | 
9 |
10 | Fazer a instalação usando o comando abaixo, **verifiquem a versão** do repositório.
11 |
12 | ```shell
13 | sudo apt install postgresql-14 -y
14 | ```
15 |
16 | ## Habilitando usuário no PostgreSQL
17 |
18 | ```shell
19 | sudo -u postgres psql
20 | alter user postgres with encrypted password 'senha_da_nasa';
21 | ```
22 |
23 | ## Habilitando acesso remoto ao servidor PostgreSQL
24 |
25 | #### Abra o arquivo
26 |
27 | ```shell
28 | sudo vim /etc/postgresql/14/main/postgresql.conf
29 | ```
30 |
31 | **Altere a linha**
32 |
33 | ```shell
34 | # listen_addresses = 'localhost' # what IP address(es) to listen on
35 | ```
36 |
37 | **Para**
38 |
39 | ```shell
40 | listen_addresses = '*' # what IP address(es) to listen on
41 | ```
42 |
43 | Retire o comentário e troque o 'localhost' por '*'
44 |
45 | Salve e feche o arquivo
46 |
47 | ------
48 |
49 | #### Abra o arquivo
50 |
51 | ```shell
52 | sudo vim /etc/postgresql/14/main/pg_hba.conf
53 | ```
54 |
55 | **Que por padrão vem**
56 |
57 | ```shell
58 | # "local" is for Unix domain socket connections only
59 | local all all peer
60 | ```
61 |
62 | ```shell
63 | # IPv4 local connections:
64 | host all all 127.0.0.1/32 scram-sha-256
65 | ```
66 |
67 | ```shell
68 | # IPv6 local connections:
69 | host all all ::1/128 scram-sha-256
70 | ```
71 |
72 | ## Altere conforme necessário
73 |
74 | **Assim ficará a regra de liberação:**
75 |
76 | ```shell
77 | # IPv4 local connections:
78 | host all all 0.0.0.0/0 scram-sha-256
79 | ```
80 |
81 | **É possível também liberar o acesso apenas a uma rede específica:**
82 |
83 | ```shell
84 | # IPv4 local connections:
85 | host all all 192.168.1.0/24 scram-sha-256
86 | ```
87 |
88 | ------
89 |
90 | #### Abra o pgadmin4 ou software de preferência e faça a conexão usando as credenciais do servidor configurado.
91 |
92 | #### Não esqueçam de reiniciar o serviço, liberar a porta no grupo de segurança ou na configuração de rede da sua Instância, de acordo com a nuvem utilizada ou VM Local.
93 |
94 | ```bash
95 | sudo service postgresql restart
96 | ```
97 |
98 |
99 |
100 | ---
101 |
102 |
103 |
104 |
105 |
106 | DNS Dinâmico NOIP
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 | Sumário
115 |
116 |
117 |
118 | ---
119 |
120 | ## Dúvidas?
121 |
122 | [@birazn](https://www.instagram.com/birazn)
123 |
124 | [Canal YouTube](https://www.youtube.com/birazn)
125 |
126 |
127 |
--------------------------------------------------------------------------------
/Aulas/07-DNS_Dinâmico_NOIP.md:
--------------------------------------------------------------------------------
1 | # Servidor DNS Dinâmico
2 |
3 |
4 |
5 |
6 | 
7 |
8 | ## O primeiro passo é criar uma conta no site do serviço gratuito no-ip.
9 | ## [Acessar o site NOIP](https://www.noip.com/)
10 |
11 | ## Criar uma conta e fazer a ativação
12 |
13 | Após ter criado a conta, inicialize sua instância na AWS e pegue o IP para configurar o domínio no NOIP
14 |
15 | 
16 |
17 | Feitas as configurações no site do serviço, agora é a hora de configurar o nosso servidor de modo a que ele envie seu novo IP para o no-ip a intervalos regulares, o que faz com que precisemos decorar somente o domínio que registramos, e não mais o IP.
18 | Isso facilita a configuração do Termius, por exemplo, não sendo mais necessário mudar o IP nele a cada vez que a instância é parada e iniciada novamente.
19 |
20 | # Client NOIP
21 |
22 | Primeiramente vamos fazer o download do arquivo do cliente e descompactá-lo no nosso servidor.
23 |
24 | ```bash
25 | cd /usr/local/src/
26 | sudo wget https://www.noip.com/client/linux/noip-duc-linux.tar.gz
27 | sudo tar xzf noip-duc-linux.tar.gz
28 | cd noip-2.1.9-1
29 | sudo apt install make gcc
30 | sudo make
31 | sudo make install
32 | ```
33 |
34 | Para executar o comando **make**, que faz a compilação dos arquivos e gera o binário, são necessários dois pacotes que não estão instalados por padrão no Ubuntu (normalmente): o próprio **make** e o **gcc**, que ja foram instalados conforme script anterior.
35 |
36 | #### Depois de feita a instalação, é necessário configurar o cliente no-ip, e isso é feito com o comando
37 |
38 | ```bash
39 | sudo /usr/local/bin/noip2 -C #note que -C é maiusculo
40 | ```
41 |
42 | **Algumas perguntas serão feitas: e-mail cadastrado no site no-ip, senha, qual o tempo de atualização do IP (em minutos), se deseja salvar as alterações e qual o arquivo de configuração.**
43 |
44 | Feita a instalação e configuração, é hora de colocar o serviço para rodar com o comando
45 |
46 | ```bash
47 | sudo /usr/local/bin/noip2
48 | ```
49 |
50 | Esse comando, executado no terminal, faz com o que o serviço passe a rodar, mas caso o servidor seja reinicializado, ele precisa ser rodado novamente. **A seguir veja como automatizar essa inicialização.**
51 |
52 | ## Colocando NOIP para iniciar automático
53 |
54 | Os vários scripts de inicialização do Ubuntu ficam no diretório **/etc/init.d**. Além disso, existem links dentro de outros diretórios de inicialização e encerramento do servidor.
55 | Uma forma prática de automatizar a execução de um comando qualquer, é criando um arquivo chamado **rc.local** dentro do diretório **etc** e dar permissão de execução para ele.
56 |
57 | **Podem ser usados vários métodos, vou deixar aqui um deles**
58 |
59 | Criar um arquivo
60 |
61 | ```bash
62 | sudo vim /etc/rc.local
63 | ```
64 |
65 | Dentro deste arquivo faça uma chamada de *script* com **shebang** e a linha de execução do noip2
66 |
67 | ```bash
68 | #!/bin/bash
69 | /usr/local/bin/noip2
70 | ```
71 |
72 | Salvar arquivo e colocar como executável
73 |
74 | ```bash
75 | sudo chmod 755 /etc/rc.local
76 | ```
77 |
78 | Reinicie o servidor para verificar se o serviço está ativo.
79 |
80 | ---
81 |
82 |
83 |
84 |
85 |
86 | Iniciando com Docker
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 | Sumário
95 |
96 |
97 |
98 | ---
99 |
100 | ## Dúvidas?
101 |
102 | [@birazn](https://www.instagram.com/birazn)
103 |
104 | [Canal YouTube](https://www.youtube.com/birazn)
105 |
106 |
--------------------------------------------------------------------------------
/Aulas/03-VirtualHosts.md:
--------------------------------------------------------------------------------
1 | # Apache - VirtualHosts
2 |
3 | 
4 |
5 |
6 |
7 | O suporte a virtual hosts é um daqueles recursos fundamentais, que possibilitaram o surgimento da Internet da forma como a conhecemos hoje.
8 | Ele permite hospedar diversos sites, com domínios ou subdomínios diferentes usando um único servidor e um único endereço IP. Os únicos limitantes com relação ao volume de sites que é possível hospedar são os recursos de hardware do servidor e a banda disponível.
9 |
10 | #### Vamos criar uma estrutura para receber nosso host virtual
11 |
12 | ```shell
13 | sudo mkdir -p /var/www/html/idss.local/public_html # -p cria a hierarquia
14 | sudo mkdir /var/www/html/idss.local/logs
15 | ```
16 |
17 | #### Criamos agora um arquivo de chamada para ids
18 |
19 | ```shell
20 | sudo vim /etc/apache2/sites-available/idss.local.conf
21 | ```
22 |
23 | #### Dentro deste arquivo colocamos a seguinte descrição
24 |
25 | ```html
26 |
27 | ServerAdmin webmaster@ids.local
28 | ServerName idss.local
29 | ServerAlias www.idss.local
30 | DocumentRoot /var/www/html/idss.local/public_html/
31 | ErrorLog /var/www/html/idss.local/logs/error.log
32 | CustomLog /var/www/html/idss.local/logs/access.log combined
33 |
34 | ```
35 |
36 | Abra o arquivo para configurar que portas o apache esta escutando
37 |
38 | ```shell
39 | sudo vim /etc/apache2/ports.conf
40 | ```
41 |
42 | Coloque o "Listen 8081" abaixo do "Listen 80"
43 |
44 | ### Salvar e fechar este arquivo
45 |
46 | #### Não esqueçam de liberar a porta 8081 no **SecurityGroup** AWS
47 |
48 | ------
49 |
50 | ### Vamos conceder as permissões
51 |
52 | ```shell
53 | sudo chown -R $USER:$USER /var/www/html/idss.local/public_html
54 | sudo chmod -R 755 /var/www/html/
55 | ```
56 |
57 | **$USER → Variável de ambiente que representa nome do usuário logado**
58 |
59 | #### Criamos um arquivo de exemplo para ids
60 |
61 | ```shell
62 | sudo vim /var/www/html/idss.local/public_html/index.html
63 | ```
64 |
65 | #### Dentro deste arquivo colocamos a seguinte descrição
66 |
67 | ```html
68 |
69 |
70 | Bem Vindo ao IDSS5 - 2024!
71 |
72 |
73 |
74 | Parabéns! O seu virtual host está funcionando!
75 |
76 |
77 | ```
78 |
79 | #### Agora criamos um link simbólico, que pode ser feito de varias formas, veja uma.
80 |
81 | Para criar e habilitar usamos **a2ensite**
82 |
83 | ```shell
84 | sudo a2ensite idss.local.conf # habilita nosso VirtualHost
85 | ```
86 |
87 | Para desabilitar o link simbólico usamos **a2dissite** (**Não é necessário desabilitar os sites, a não ser que esteja desativando algum**)
88 | ```shell
89 | sudo a2dissite idss.local.conf # só execute, quando for necessario desabilitar
90 | ```
91 |
92 | Desativem o principal, **caso queiram deixar APENAS o *virtualhost*:**
93 | ```shell
94 | sudo a2dissite 000-default.conf # para que o virtualhost execute na página principal
95 | ```
96 |
97 |
98 |
99 | ### Restart o serviço apache2
100 |
101 | ```shell
102 | sudo service apache2 restart
103 | ```
104 |
105 | ### Sempre que fizer uma mudança da configuração, não esqueça de reiniciar o serviço
106 |
107 |
108 |
109 |
110 |
111 | LAMP
112 |
113 |
114 |
115 |
116 |
117 |
118 | Sumário
119 |
120 |
121 |
122 | ---
123 | ## Dúvidas?
124 |
125 | [@birazn](https://www.instagram.com/birazn)
126 |
127 | [Canal YouTube](https://www.youtube.com/birazn)
128 |
129 |
--------------------------------------------------------------------------------
/Aulas/012-Subindo_imagem_para_DockerHub.md:
--------------------------------------------------------------------------------
1 | # Subindo imagem para Docker Hub
2 |
3 | Para enviarmos uma imagem pronta para o docker hub é necessário, alem de todos os procedimentos para geração, "*build*", da imagem, ter uma conta criada.
4 |
5 |
6 |
7 | ## Criar conta no Docker Hub
8 |
9 | ### O que é o Docker Hub
10 |
11 | Dockerhub é um Serviço de Web Hosting compartilhado para imagens Docker, é nele que os **Dockerfiles** disponibilizadas para a comunidade, bem como **imagens oficiais** também são disponibilizadas por grandes grupos para facilitar o trabalho na hora de criar uma infraestrutura Docker.
12 |
13 | Para criar sua conta acesse o site https://hub.docker.com/ e faça seu cadastro.
14 |
15 | 
16 |
17 | Após seu cadastro faça login, na interface terá uma tela sem repositório onde poderá cria-los diretamente pelo sistema ou serão gerados automaticamente durante os "*Puchs*", enviando suas imagens. **Pode ser necessário acessar o e-mail de cadastro para confirmação.**
18 |
19 | 
20 |
21 | A conta gratuita possui direito a um repositório privado. Existem planos pagos, caso queira mais repositórios privados, isso geralmente é voltado para empresas que usam Docker em sua infraestrutura.
22 |
23 | Com a sua conta criada é a hora de fazer o primeiro envio de imagem para o repositório, caso ainda não tenha entendido a ideia, é totalmente semelhando ao que faz subindo seus projetos e códigos para o Github.
24 |
25 | Para listar as nossas imagens, use o comando docker images ou docker image ls
26 |
27 | ```bash
28 | docker images
29 | ```
30 |
31 | Obtendo um resultado semelhante a mostrado na imagem.
32 |
33 | 
34 |
35 | Caso ainda não tenha nenhuma imagem criada, vamos criar a primeira, usando procedimento da [aula anterior](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/011-Primeiro_Dockerfile.md) com o Dockerfile.
36 |
37 | ```bash
38 | FROM ubuntu
39 | LABEL maintainer="@birazn"
40 | RUN apt update
41 | RUN apt install apache2 -y
42 | RUN apt autoclean
43 |
44 | EXPOSE 80
45 | CMD ["apache2ctl", "-D", "FOREGROUND"]
46 | ```
47 |
48 | Após a criação do arquivo é necessária criação dessa imagem.
49 |
50 | ```bash
51 | docker build -t serverweb:1.0 .
52 | ```
53 |
54 | > #### Lembrando que cada Dockerfile deve estar dentro de seu diretório
55 |
56 | Feita a imagem é possivel executar normalmente como vinhamos fazendo com as imagens externas, para testar se está tudo correto.
57 |
58 | ```bash
59 | docker container run --name MeuServidor -d serverweb:1.0
60 | ```
61 |
62 | Antes de enviarmos nossa imagem para a nuvem precisamos "taggea-la" com o comando *docker tag*, isso é importante para identificarmos o ID atual da imagem e também para indicarmos o usuário da conta no Docker Hub.
63 |
64 | ```bash
65 | docker tag b6182e430414 SEU_DOCKER_ID/serverweb:1.0
66 | ```
67 |
68 | Faça o login com comando `docker login`, coloque suas credenciais e receberá mensagem "**Login Succeeded*"
69 |
70 | Execute o *push* para "*empurrar*" sua imagem para o repositório.
71 |
72 | ```
73 | docker push birazn/serverweb:1.0
74 | ```
75 |
76 | Será gerada uma mensagem de envio com um hash sha256
77 |
78 | Verifique diretamente no site, se o repositório foi enviado, após isso todos podem usar esta imagem gerada para criar seus *container* baseado na sua infraestrutura.
79 |
80 | ---
81 |
82 |
83 |
84 |
85 | Proximo
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 | Sumário
94 |
95 |
96 |
97 | ---
98 |
99 | ## Dúvidas?
100 |
101 | [@birazn](https://www.instagram.com/birazn)
102 |
103 | [Canal YouTube](https://www.youtube.com/birazn)
104 |
105 |
--------------------------------------------------------------------------------
/Aulas/05-Paginas_Pessoais.md:
--------------------------------------------------------------------------------
1 | # Configurando Páginas Pessoais
2 |
3 |
4 |
5 | É possível oferecer a cada utilizador a possibilidade de criar páginas Internet pessoais.
6 |
7 | Uma vez concluída a instalação do **Apache2**, a configuração do suporte para páginas pessoais consiste na ativação do módulo ***userdir*** do servidor apache2.
8 |
9 | ```bash
10 | sudo a2enmod userdir
11 | sudo systemctl restart apache2
12 | ```
13 |
14 | ### Ativar suporte ao PHP
15 |
16 | A execução de *scripts* php está desativada nas páginas pessoais.
17 |
18 | ```bash
19 | sudo vim /etc/apache2/mods-available/php8.1.conf
20 | ```
21 |
22 | no arquivo /etc/apache2/mods-available/php8.1.conf (Verificar a versão do PHP instalado)
23 |
24 | Para ativar, é necessário comentar a linha:
25 |
26 | \# **php_admin_flag engine Off**
27 |
28 |
29 |
30 | **Não esqueça de reiniciar o servidor web**
31 |
32 | ```bash
33 | sudo service apache2 restart
34 | ```
35 |
36 | ## A utilização
37 |
38 | As páginas pessoais são acessíveis através de um endereço:
39 |
40 | **http://ip_do_servidor/~nome_usuario**
41 |
42 | Quando o servidor recebe um pedido deste, tenta encontrar e servir o conteúdo de um diretório específico chamada **public_html** na home do usuário.
43 |
44 | Portanto, para que cada usuário possa criar as suas páginas deve, antes de mais nada, criar um diretório chamada “**public_html**” na sua home, onde colocará os conteúdos.
45 |
46 | ### Criando o diretório, no usuário existente
47 |
48 | ```bash
49 | mkdir ~/public_html
50 | ```
51 |
52 | Uma vez criado o diretório, o usuário pode começar a criar conteúdos.
53 |
54 | Na pasta **public_html** crie um arquivo **index.html**
55 |
56 | ```bash
57 | vim ~/public_html/index.html
58 | ```
59 |
60 | Coloque o código para efetuar o teste.
61 |
62 | ```html
63 |
64 |
65 |
66 | Bem Vindo ao IDSS - Página Pessoal!
67 |
68 |
69 |
70 | Página pessoal – Olá Mundo
71 | Bem Vindo!
72 |
73 |
74 | ```
75 |
76 | ## Configurando permissões
77 |
78 | ```bash
79 | chmod 711 $HOME
80 | chmod -R 755 ~/public_html
81 | ```
82 |
83 | **$HOME** variável de ambiente que pega pasta base do usuário logado
84 |
85 | ## Automatizando processo para futuros usuários
86 |
87 | Para que o diretório **public_html** seja criado automaticamente quando for criado um novo usuário, é adicionada a entrada em **/etc/skel**, com direitos de acesso exclusivos para próprio utilizador:
88 |
89 | ```bash
90 | sudo mkdir /etc/skel/public_html
91 | sudo chmod 0700 /etc/skel/public_html
92 | ```
93 |
94 | ## Criando usuário para teste
95 |
96 | ```bash
97 | sudo adduser teste
98 | sudo ls /home/teste
99 | ```
100 |
101 | Verificar se dentro da pasta do usuário, existe a **'public_html'** configurada na **skel**
102 |
103 | ## Refazendo as etapas, agora para usuário teste
104 |
105 | ```bash
106 | su teste
107 | chmod 711 $HOME
108 | chmod -R 755 ~/public_html
109 | vim ~/public_html/index.html
110 | ```
111 |
112 | ```html
113 |
114 |
115 |
116 | Bem Vindo ao IDSS - Página Pessoal! Teste
117 |
118 |
119 |
120 | Página pessoal do Teste – Olá Mundo
121 | Bem Vindo!
122 |
123 |
124 | ```
125 |
126 | ---
127 |
128 |
129 |
130 |
131 |
132 | PostgreSQL
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 | Sumário
141 |
142 |
143 |
144 | ---
145 |
146 | ## Dúvidas?
147 |
148 | [@birazn](https://www.instagram.com/birazn)
149 |
150 | [Canal YouTube](https://www.youtube.com/birazn)
151 |
152 |
--------------------------------------------------------------------------------
/Aulas/04-LAMP.md:
--------------------------------------------------------------------------------
1 | # Instalando e Configurando LAMP
2 |
3 |
4 |
5 |
6 |
7 |
8 | Uma stack LAMP é um pacote de, no mínimo, quatro tecnologias de software diferentes que os desenvolvedores usam para criar sites e aplicativos web. LAMP é um acrônimo para o sistema operacional **Linux**; o servidor web, **Apache**; o servidor de banco de dados, **MySQL**; e a linguagem de programação, **PHP**.
9 |
10 | ## Atualizando repositórios
11 |
12 | ```bash
13 | sudo apt update
14 | sudo apt upgrade
15 | ```
16 |
17 | > ***É importante que o Servidor Web já esteja instalado e configurado. Neste caso, estamos usando o Apache 2.***
18 |
19 | ---
20 |
21 |
22 |
23 | # PHP
24 |
25 | É o interpretador que torna possível a execução de paginas dinâmicas e interativa usando seus próprios *scripts* e *frameworks*.
26 |
27 | **(para Ubuntu 22.04 – verificando a versão PHP)**
28 |
29 | > É extremamente importante verificar a versão do PHP antes de executar o comando.
30 |
31 | ```bash
32 | sudo apt install libapache2-mod-php8.1 php8.1 php8.1-mysql php8.1-pgsql
33 | ```
34 |
35 | **(para versões diferentes verifique a versão do PHP)**
36 |
37 | Criar o diretório de log para PHP e dar permissão do usuário Apache:
38 |
39 | ```bash
40 | sudo mkdir /var/log/php
41 | sudo chown www-data /var/log/php
42 | ```
43 |
44 | **(www-data é usuário do apache)**
45 |
46 | Crie um arquivo funcionalidades.
47 |
48 | ```bash
49 | sudo vim /var/www/html/phpinfo.php
50 | ```
51 |
52 | ```php
53 |
56 | ```
57 |
58 | **Se funcionar siga para o próximo passo**
59 |
60 | http://ip_do_servidor/phpinfo.php
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 | ## MySQL
69 |
70 | O MySQL é um sistema de gerenciamento de banco de dados relacional (SGBDR) e é um componente popular de muitas aplicações.
71 |
72 | ```bash
73 | sudo apt install mysql-server
74 | ```
75 |
76 | #### Verificando serviço
77 |
78 | ```bash
79 | sudo service mysql status # forma convencional
80 | ```
81 |
82 | ### OU
83 |
84 | ```bash
85 | sudo systemctl status mysql # forma mais atual
86 | ```
87 |
88 | #### Logando como root sem senha inicial
89 |
90 | ```bash
91 | sudo mysql
92 | ```
93 |
94 | **Deve cair em um prompt**
95 |
96 | ```bash
97 | mysql>
98 | ```
99 |
100 | Se você quiser fazer login como root através de programas externos, como o **phpMyAdmin**, você tem **duas opções**:
101 |
102 | **A primeira opção é alterando o método de autenticação do usuário root [BÁSICO]:**
103 |
104 | ```sql
105 | ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'senha_da_nasa';
106 | FLUSH PRIVILEGES;
107 | ```
108 |
109 | **E a segunda e recomendada é criar um usuário administrativo com acesso a todos os bancos de dados, sem alterar o método de autenticação do root:** (indicada)
110 |
111 | ```sql
112 | CREATE USER 'idss'@'localhost' IDENTIFIED BY 'senha_da_nasa';
113 | GRANT ALL PRIVILEGES ON *.* TO 'idss'@'localhost' WITH GRANT OPTION;
114 |
115 | CREATE DATABASE idss2024;
116 | CREATE USER 'idsslim'@'localhost' IDENTIFIED BY 'senha_da_nasa';
117 | GRANT ALL ON idss2024.* TO 'idsslim'@'localhost' WITH GRANT OPTION;
118 | ```
119 |
120 | > **CASO QUEIRA liberar acesso remoto para outros programas**
121 |
122 | ```bash
123 | sudo vim /etc/mysql/mysql.conf.d/mysqld.cnf # NÃO É OBRIGATÓRIO
124 | ```
125 |
126 | Comente a linha do **bind-address**
127 |
128 | Repita a linha do GRANT ALL trocando localhost pelo IP do servidor.
129 | Não esqueça de Liberar no Security Group AWS a porta padrão, 3306 ou a porta que configurou no seu MySQL
130 |
131 | ---
132 |
133 |
134 |
135 | ## PHP MyAdmin
136 |
137 | ```bash
138 | sudo apt install phpmyadmin
139 | ```
140 |
141 | Marcar a opção do servidor web que está utilizando com **Apache**. [***Selecione com barra de espaço***]
142 |
143 | Configurar o banco integrando com phpmyadmin.
144 |
145 | Para acessar o phpmyadmin acesse o endereço local ou http://IP-do-servidor/phpmyadmin que terá que abrir.
146 |
147 |
148 |
149 | ### Ocultando tabelas de configuração
150 |
151 | Com o PHPMyAdmin aberto, siga os passos
152 |
153 | Configurações > Recursos > Banco de Dados
154 |
155 | 
156 |
157 | Inclua a lista de nomes do banco de dados que deseja ocultar, separados por | [pipe].
158 |
159 |
160 |
161 | ## Após a instalação [OPCIONAL]
162 |
163 | > para remover o banco de dados de teste e quaisquer permissões de usuário estranhos adicionados durante o processo inicial de instalação, para configurar e melhorar a segurança do seu servidor MySQL
164 |
165 | ```bash
166 | sudo mysql_secure_installation
167 | ```
168 |
169 | Esta configuração, exibirá a opção **VALIDATE PASSWORD COMPONENT** usada como validação de senhas fortes para usuários do MySQL.
170 |
171 | Pedirá a senha do **root** configurada anteriormente;
172 | Mostra informações sobre o componente;
173 | A força da senha será testada;
174 |
175 | - Oferece possibilidade de alterar senha do **root** (**n**);
176 | - Remover usuário anônimo **sim (Y)**;
177 | - Remover acesso remoto **sim (Y)**; (tira acesso remoto com root)
178 | - Remover banco de dados de teste **sim (Y)**;
179 | - recarregar privilégios agora **sim (Y)**.
180 |
181 | # Caso necessite DESABILITAR a validação.
182 |
183 | ## MySQL 5.7 version
184 |
185 | Login to MySQL :
186 |
187 | ```bash
188 | sudo mysql -u root -p
189 | Enter Password:
190 |
191 | mysql> uninstall plugin validate_password;
192 | Query OK, 0 rows affected (0.02 sec)
193 | ```
194 | Habilitar novamente
195 | ```bash
196 | sudo mysql -u root -p
197 | Enter Password:
198 |
199 | mysql> install plugin validate_password SONAME 'validate_password.so';
200 | Query OK, 0 rows affected (0.02 sec)
201 | ```
202 |
203 | Verificar se funcionou.
204 |
205 | ```bash
206 | vim /etc/my.cnf
207 | validate_password_policy=LOW
208 | ```
209 |
210 | ## MySQL 8.0 version
211 |
212 | Login to MySQL :
213 |
214 | ```bash
215 | sudo mysql -u root -p
216 | Enter Password:
217 |
218 | mysql>UNINSTALL COMPONENT 'file://component_validate_password';
219 | Query OK, 0 rows affect
220 | ```
221 |
222 | Habilitar novamente
223 | ```bash
224 | sudo mysql -u root -p
225 | Enter Password:
226 |
227 | mysql>INSTALL COMPONENT 'file://component_validate_password';
228 | Query OK, 0 rows affected (0.02 sec)
229 | ```
230 |
231 |
232 |
233 |
234 |
235 | Páginas Pessoais
236 |
237 |
238 |
239 |
240 |
241 |
242 |
243 | Sumário
244 |
245 |
246 |
247 | ---
248 |
249 | ## Dúvidas?
250 |
251 | [@birazn](https://www.instagram.com/birazn)
252 |
253 | [Canal YouTube](https://www.youtube.com/birazn)
254 |
255 |
--------------------------------------------------------------------------------
/Aulas/08-Iniciando_com_Docker.md:
--------------------------------------------------------------------------------
1 | # Iniciando com Docker
2 |
3 |
4 |
5 | ## Docker Engine+CLI vs Docker Desktop
6 |
7 | A Engine Docker, roda diretamente e por padrão no Linux como CLI (***Command Line Interface***), da mesma forma como começou por volta de 2013. É importante lembrar que, no manuseio e gerenciamento direto nos servidores em nuvem ou local, isso acontece em CLI. O consumo de recursos usando desta forma é bem inferior, ampliando as possibilidades, mesmo com hardwares mais modestos. Em Linux, podemos executar somente a Engine Docker, o CLI ou as demais ferramentas e plugins existentes instalando manualmente.
8 |
9 | O Docker Desktop trabalha um pouco diferente, criando uma maquina virtual minúscula, dentro do ambiente do Linux, a exemplo do que é feito nos ambientes gráficos Mac e Windows. O motivo de fazer desta forma, ao invés de simplesmente criar uma GUI (***Graphical User Interface***) para gerenciar a Engine Docker, é compatibilizar a experiencia dos usuários nos três principais ambientes do mercado. Lembrando que esta solução trás a facilidade no controle de *containers* locais em ambientes de desenvolvimento.
10 |
11 | Com esta interface do Docker Desktop, fica mais fácil criar, excluir e editar os *containers,* com suas imagens, redes, volumes e demais recursos que podem ser criados.
12 |
13 | Se você é um iniciante em tecnologias de *containers* é interessante que comece com o Docker Deskop, até ter mais conhecimento e prática na utilização do CLI.
14 |
15 | ## Docker Comandos
16 |
17 | Docker é uma plataforma de software que permite criar, testar e implantar aplicativos rapidamente, usando contêineres. Com o Docker, os desenvolvedores podem criar um ambiente de desenvolvimento completo, incluindo servidores, bibliotecas e dependências, em um contêiner e implantá-lo facilmente em qualquer lugar.
18 |
19 | A seguir, estão alguns dos comandos mais comuns do Docker:
20 |
21 | - **docker container run**: Este comando é usado para criar e executar um contêiner a partir de uma imagem do Docker. A sintaxe básica é `docker container run image_name`, onde `image_name` é o nome da imagem que você deseja executar.
22 | - **docker container ls**: Este comando é usado para listar todos os contêineres em execução no sistema. A sintaxe básica é `docker container ls`.
23 | - **docker container ls -a**: Este comando é usado para listar todos os contêineres no sistema. A sintaxe básica é `docker container ls -a`.
24 | - **docker container start/stop/restart/pause/unpause**: Estes comando são usados para iniciar/parar/reiniciar/pausar/despausar um contêiner em execução. A sintaxe básica é `docker container start/stop/restart/pause/unpause container_name`, onde `container_name` é o nome do contêiner que você deseja parar.
25 | - **docker container rm**: Este comando é usado para remover um contêiner. A sintaxe básica é `docker container rm container_name`, onde `container_name` é o nome do contêiner que você deseja remover.
26 | - **docker image rm**: Este comando é usado para remover uma imagem do Docker. A sintaxe básica é `docker image rm image_name`, onde `image_name` é o nome da imagem que você deseja remover, `os containers criados a partir desta imagem precisa estar parados`.
27 | - **docker container inspect:** Este comando é usado para mostrar todas as informações referentes a um determinado container. A sintaxe básica é `docker container inspect image_name`, onde `image_name` é o nome da imagem que você deseja verificar.
28 |
29 | Esses são apenas alguns dos comandos mais comuns do Docker. Existem muitos outros comandos disponíveis, e você pode encontrar mais informações na documentação oficial do Docker.
30 |
31 | ## Documentação de Referência
32 |
33 | ## [Descomplicando Docker](https://livro.descomplicandodocker.com.br/)
34 |
35 | ---
36 |
37 | # Conceito de Container
38 |
39 | ## Isolamento de Recursos
40 |
41 | - CPU
42 | - Memoria
43 | - Discos
44 | - Networks
45 | - Processo
46 | - Filesystens
47 |
48 | ## Principal diferença VM x Container
49 |
50 | - Complexidade
51 | - Vulnerabilidades, quando um patch de segurança precisa ser aplicado, em VMs é necessário atualizar todos os sistemas operacionais instalados, enquanto que Docker, basta aplicar no sistema operacional base.
52 | - Container runtime é nativo linux
53 |
54 | ## Imagem mostrando a diferença
55 |
56 | 
57 |
58 | ## Imagem de Container
59 |
60 | - Somente o necessário para APP funcionar
61 |
62 | ---
63 |
64 | ## Docker [Popularizou a 2ªGeração de Container]
65 |
66 | - LXC LXD DotCloud
67 |
68 | ### Orquestração
69 |
70 | 
71 |
72 | ---
73 |
74 | # Comandos na Prática
75 |
76 | Trabalhando com docker em máquina local.
77 |
78 | O Docker está disponível em duas versões:
79 |
80 | - Docker Community Edition (Docker CE) **[free]**
81 | - Docker Enterprise Edition (Docker EE) **[pago]**
82 |
83 | O processo de instalação é bem simples, usando a referencia do próprio Docker.
84 |
85 | ## Pegar o script e executar em Bash
86 |
87 | ```bash
88 | curl -fsSL https://get.docker.com | bash
89 | ```
90 |
91 | #### A linha executa um *script* que já identifica a sua distro de Linux e faz a instalação de tudo que for necessário.
92 |
93 | > **Para as versões de Linux Mint é necessário utilizar outro processo, verifique o arquivo de instalação exclusivo desta distro.** [Linux Mint 21](https://github.com/birazn/IDS-IFSPVTP/blob/master/Aulas/09-Docker_LinuxMint_21.md)
94 |
95 | ### Após a instalação faça o teste verificando qual versão foi instalada.
96 |
97 | ```bash
98 | sudo docker version
99 | ```
100 |
101 | ### Caso queira utilizar em maquina local sem a necessidade de executar usando **sudo** adicione o usuário no grupo do Docker.
102 |
103 | ```bash
104 | sudo usermod -aG docker $USER
105 | ```
106 |
107 | > **Nos comandos pratico utilizaremos, já tendo o usuário no grupo Docker.**
108 |
109 | #### Verificar se existe container em execução
110 |
111 | ```bash
112 | docker container ls
113 | ```
114 |
115 | #### Verificar se existe container em execução ou parado
116 |
117 | ```bash
118 | docker container ls -a
119 | ```
120 |
121 | #### Vamos rodar nosso primeiro container
122 |
123 | ```bash
124 | docker container run hello-world
125 | ```
126 |
127 | #### Neste processo ele verifica se a imagem do hello-world existe, baixa e executa diretamente, Oferecendo a saída
128 |
129 | ```bash
130 | Unable to find image 'hello-world:latest' locally
131 | latest: Pulling from library/hello-world
132 | 2db29710123e: Pull complete
133 | Digest: sha256:4e83453afed1b4fa1a3500525091dbfca6ce1e66903fd4c01ff015dbcb1ba33e
134 | Status: Downloaded newer image for hello-world:latest
135 |
136 | Hello from Docker!
137 | This message shows that your installation appears to be working correctly.
138 |
139 | To generate this message, Docker took the following steps:
140 |
141 | 1. The Docker client contacted the Docker daemon.
142 | 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
143 | (amd64)
144 | 3. The Docker daemon created a new container from that image which runs the
145 | executable that produces the output you are currently reading.
146 | 4. The Docker daemon streamed that output to the Docker client, which sent it
147 | to your terminal.
148 |
149 | To try something more ambitious, you can run an Ubuntu container with:
150 | $ docker run -it ubuntu bash
151 |
152 | Share images, automate workflows, and more with a free Docker ID:
153 | https://hub.docker.com/
154 |
155 | For more examples and ideas, visit:
156 | https://docs.docker.com/get-started/
157 | ```
158 |
159 | #### Seguindo a própria indicação do "hello-world", vamos agora executar um container e abrir um terminal interativo para podermos manipular.
160 |
161 | > **O ENTRYPOINT é o principal comando a ser executado quando o container sobe. Ele deve ser, inclusive, um comando que prende o terminal, caso contrário o container apenas sobe e desce não se mantendo útil. Esse comando deve receber um array ou mesmo um parâmetro único. No nosso exemplo será o 'bash'.**
162 |
163 | ```bash
164 | docker run -it ubuntu bash
165 | ```
166 |
167 | Se sairmos do container usando comandos comuns de linux vamos "matar" processo, pois, o que esta em execução no momento é somente o **bash**. Usar o ***exit*** ou ***ctrl+d*** sairá parando a execução do container.
168 |
169 | Para que possamos sair do container, mantendo em execução, usamos o ***ctrl+p+q***.
170 |
171 | Caso eu queira voltar para o container em execução, posso usar:
172 |
173 | ```bash
174 | docker container attach [CONTAINER ID]
175 | ```
176 |
177 | Então o parâmetro ***run*** é utilizado para executar um container, estando ele na maquina ou não.
178 |
179 | Outros parâmetros usam basicamente o mesmo formato, em alguns casos dispensando o ***-it*** do terminal interativo.
180 |
181 | ```bash
182 | # docker container [start/stop/restart] [CONTAINER ID]
183 | docker container start [CONTAINER ID]
184 | docker container stop [CONTAINER ID]
185 | docker container restart [CONTAINER ID]
186 | ```
187 |
188 | > Lembrando, para obter informações dos containers em execução usamos: **docker container ls**
189 |
190 | Temos também o parâmetros ***inspect*** que gera uma saída com todas as informações sobre o container que for chamado.
191 |
192 | ```bash
193 | docker container inspect [CONTAINER ID]
194 | ```
195 |
196 | Podem ser usados também os parâmetros ***pause*** e ***unpause***, que irá pausar ou "despausar" o container.
197 |
198 | Ainda é possível verificar as informações de execução de um container com o parâmetro ***stats***
199 |
200 | ```bash
201 | docker container stats [CONTAINER ID]
202 | ```
203 |
204 | Quando não queremos mais utilizar aquele container podemos exclui-lo com parametro **rm**.
205 |
206 | ```bash
207 | docker container rm [CONTAINER ID]
208 | ```
209 | ---
210 |
211 | # [Livro de referência](https://livro.descomplicandodocker.com.br/chapters/chapter_01.html)
212 |
213 |
214 |
215 |
216 |
217 | Docker Linux Mint 21
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 | Sumário
226 |
227 |
228 |
229 | ---
230 |
231 | ## Dúvidas?
232 |
233 | [@birazn](https://www.instagram.com/birazn)
234 |
235 | [Canal YouTube](https://www.youtube.com/birazn)
236 |
237 |
--------------------------------------------------------------------------------
