Tutorial: Trabalhar com a estrutura da Web Django no Visual Studio

Este artigo é a primeira etapa de uma série de tutoriais de cinco partes que demonstra como trabalhar com o Django no Visual Studio. Django é um framework Python de alto nível projetado para desenvolvimento web rápido, seguro e escalável. O Visual Studio fornece modelos de projeto que você pode usar para simplificar a criação de aplicativos Web baseados em Django. Esta série de tutoriais explora a estrutura Django no contexto dos modelos de projeto do Visual Studio.

Na Etapa 1 do tutorial, você aprenderá a:

• Criar um projeto de aplicativo Web Django usando o modelo Projeto Web Django em Branco
• Examine o código clichê e execute o aplicativo
• Criar um repositório Git para o aplicativo Web Django
• Trabalhar com controles de código-fonte Git
• Criar um ambiente virtual para o aplicativo Web Django

Pré-requisitos

• Visual Studio 2022 ou posterior no Windows com as seguintes opções selecionadas no Visual Studio Installer:

  • No separador Workloads, selecione a opção de desenvolvimento Python . Para obter mais informações, consulte Instalar suporte a Python no Visual Studio.

  • Na guia Componentes individuais em Ferramentas de código, selecione a opção Git para Windows.

Os modelos de projeto Django no Visual Studio estão incluídos em todas as versões anteriores do Python Tools for Visual Studio. Os detalhes do modelo podem diferir das descrições nesta série de tutoriais, especialmente para versões anteriores da estrutura da web do Django.

O Visual Studio para Mac não é suportado. Para obter mais informações, consulte O que está acontecendo com o Visual Studio para Mac? Visual Studio Code no Windows, Mac e Linux funciona bem com Python por meio de extensões disponíveis.

Projetos do Visual Studio e projetos Django

Na terminologia Django, um projeto Django tem vários arquivos de configuração no nível do site, juntamente com um ou mais "aplicativos". Para criar um aplicativo Web completo, você pode implantar esses aplicativos em um host da Web. Um projeto Django pode conter vários aplicativos, e o mesmo aplicativo pode estar em vários projetos Django.

Um projeto do Visual Studio pode conter o projeto Django junto com vários aplicativos. Nesta série de tutoriais, o termo "projeto" refere-se ao projeto do Visual Studio. Quando o conteúdo se refere à parte "Projeto Django" da aplicação web, está se referindo a um "Projeto Django" especificamente.

Criar projeto e solução do Visual Studio

Na etapa 1 desta série de tutoriais, você cria uma única solução do Visual Studio para conter vários projetos Django. Cada projeto contém um único aplicativo Django. Você cria os projetos usando diferentes modelos de projeto Django incluídos no Visual Studio. Ao manter os projetos na mesma solução, você pode alternar facilmente entre diferentes arquivos para comparação.

Quando você trabalha com o Django a partir da linha de comando, geralmente inicia um projeto executando o django-admin startproject <project_name> comando. No Visual Studio, o modelo Blank Django Web Project fornece a mesma estrutura dentro de um projeto e solução do Visual Studio.

Siga este procedimento para criar a solução e o projeto:

1. No Visual Studio, selecione Arquivo>Novo>Projeto e procure "Django". Em seguida, selecione o modelo Blank Django Web Project e selecione Next.

   

2. Configure seu novo projeto e solução:

   1. Defina o Nome do do projeto do Visual Studio como BasicProject. Este nome também é usado para o projeto Django.

   2. Especifique o Local para o Visual Studio salvar a solução e o projeto.

   3. Desmarque a solução Place e o projeto no mesmo diretório opção.

   4. Defina o nome da solução como LearningDjango. A solução serve como contêiner para vários projetos nesta série de tutoriais.

3. Selecione Criar.

4. Após um momento, o Visual Studio exibe o prompt arquivo de especificação do pacote Python "requirements.txt" foi detetado no projeto "BasicProject".:

   

   A caixa de diálogo indica que o modelo selecionado inclui um arquivo de requirements.txt que você pode usar para criar um ambiente virtual para o projeto.

5. Selecione o X à direita para fechar o prompt. Mais adiante neste tutorial, você cria o ambiente virtual e garante que o controle do código-fonte exclua o ambiente. (O ambiente sempre pode ser criado posteriormente a partir do arquivo requirements.txt.)

Examinar controles Git

No próximo procedimento, você se familiariza com o suporte do Visual Studio para controle de origem Git.

Importante

No Visual Studio 2019 e posterior, a experiência de controle de versão do Git está ativada por padrão. Se você quiser saber mais sobre como ele se compara com o Team Explorer, consulte a página Comparação lado a lado do Git e do Team Explorer .

Se você preferir continuar a usar o Team Explorer em versões anteriores do Visual Studio, vá para Ferramentas>Opções> deRecursos de Visualização> e alterne a caixa de seleção Nova experiência do usuário do Git.

1. Para confirmar o projeto em seu controle de código-fonte local, selecione Adicionar ao controle do código-fonte no canto inferior direito da janela principal do Visual Studio e, em seguida, selecione Git:

   

   A janela Create Git repository é aberta, onde você pode criar e enviar por push um novo repositório.

2. Depois de criar um repositório, a barra de controles Git aparece no canto inferior direito da janela principal do Visual Studio:

   

   Da esquerda para a direita, a barra de controles do Git mostra o número de confirmações de saída/entrada (setas #/#), o número de alterações não confirmadas (lápis #), o nome da ramificação atual e o nome do repositório atual. Os controles Git também estão disponíveis no menu Git na barra de ferramentas principal.

3. Na barra de controlo do Git, selecione as alterações (lápis #) para abrir a janela Alterações do Git. Você também pode selecionar Ver>alterações no Git (Ctrl+O, Ctrl+G):

   

   Esta janela mostra detalhes sobre quaisquer alterações não confirmadas, incluindo alterações ocultas. Como seu projeto recém-criado já está comprometido com o controle do código-fonte automaticamente, você não verá nenhuma alteração pendente.

4. Na barra de controles do Git, selecione as confirmações (setas #/#) e, em seguida, selecione Exibir todas as confirmações:

   

   A janela repositório Git é aberta. Você também pode selecionar Exibir>repositório Git (Ctrl+O, Ctrl+R):

   

   Esta janela mostra detalhes do repositório atual no painel esquerdo e da ramificação atual com confirmações de saída/entrada no painel direito.

   Para visualizar as diferenças do arquivo, selecione um commit no painel central. A versão anterior é exibida no lado esquerdo e a versão revisada mostra no lado direito. Os detalhes também contêm o autor da alteração, o committer da alteração e a mensagem de confirmação.

Ao trabalhar nesta série de tutoriais, adquira o hábito de usar periodicamente os controles Git no Visual Studio para confirmar e enviar alterações. O tutorial vai lembrá-lo nos pontos apropriados.

Use o controle do código-fonte desde o início

Há várias vantagens em usar o controle do código-fonte desde o início de um projeto. Quando você usa o controle do código-fonte desde o início de um projeto, especialmente se você também usa um repositório remoto, você ganha backup externo regular do seu projeto. Ao contrário de manter um projeto apenas em um sistema de arquivos local, o controle do código-fonte também fornece um histórico de alterações completo e a fácil capacidade de reverter um único arquivo ou todo o projeto para um estado anterior. O histórico de alterações ajuda a determinar a causa das regressões (falhas de teste).

O controle do código-fonte é essencial se várias pessoas estiverem trabalhando em um projeto, porque ele gerencia substituições e fornece resolução de conflitos. O controle do código-fonte é fundamentalmente uma forma de automação, prepara você bem para automatizar compilações, testes e gerenciamento de versões. É a primeira etapa no uso do Azure DevOps para um projeto e, como as barreiras à entrada são tão baixas, não há motivo para não usar o controle do código-fonte desde o início.

Para obter mais informações sobre o controle do código-fonte como automação, consulte The Source of Truth: The Role of Repositories in DevOps, um artigo na MSDN Magazine escrito para aplicativos móveis que se aplica também a aplicativos Web.

Impedir que o Visual Studio confirme automaticamente projetos

Siga estas etapas para impedir que o Visual Studio confirme automaticamente um novo projeto:

1. Abre o painel Ferramentas>Opções e expande a secção Todas as Definições>Controlo de Versões>Definições Git.

2. Desmarcar a opção Commit changes após a fusão, por defeito.

Criar ambiente virtual e excluir o controle do código-fonte

Depois de configurar o controle do código-fonte para seu projeto, você pode criar o ambiente virtual com os pacotes Django necessários que o projeto exige. Em seguida, você pode usar a janela Git Changes para excluir a pasta do ambiente do controle do código-fonte.

1. No Explorador de Soluções, clique com o botão direito do mouse no nó Ambientes Python e selecione Adicionar Ambiente.

   

2. Na caixa de diálogo Adicionar ambiente, selecione Criar para aceitar os valores predefinidos. (Você pode alterar o nome do ambiente virtual se desejar, o que altera o nome de sua subpasta, mas env é uma convenção padrão.)

   

3. Se o Visual Studio solicitar privilégios de administrador, forneça seu consentimento. Aguarde alguns minutos enquanto o Visual Studio baixa e instala pacotes. Para o Django e suas dependências, o processo pode exigir a expansão de cerca de 1.000 arquivos em mais de 100 subpastas. Você pode exibir o progresso na janela Visual Studio Output.

4. Na barra de controles do Git, selecione as alterações não confirmadas (que agora mostra 99+) para abrir a janela Git Changes:

   

   A criação do ambiente virtual traz milhares de alterações, mas você não precisa incluí-las no controle do código-fonte. Você ou qualquer outra pessoa que clone o projeto sempre pode recriar o ambiente usando o arquivo requirements.txt.

5. Para excluir o ambiente virtual do controle do código-fonte, na janela Alterações do Git, clique com o botão direito do mouse na pasta env e selecione Ignorar estes itens locais:

   

   Depois de excluir o ambiente virtual, as únicas alterações restantes são no arquivo de projeto (.py) e no arquivo de .gitignore, que contém uma entrada adicionada para a pasta do ambiente virtual.

   Para ver a vista de diferenças para o ficheiro .gitignore, na janela Git Changes, clique duas vezes no ficheiro.

6. Na janela Git Changes, insira uma mensagem de confirmação, como "Alterações iniciais do projeto":

   

7. No menu suspenso Confirmar, selecione Confirmar em etapas e Enviar.

Você pode abrir a janela Repositório Git e confirmar que os commits encenados são exibidos no Histórico Local para a ramificação atual.

Compreender o propósito dos ambientes virtuais

Um ambiente virtual é uma ótima maneira de isolar as dependências exatas do seu aplicativo. Esse método de isolamento evita conflitos dentro de um ambiente Python global e ajuda tanto no teste quanto na colaboração. Com o tempo, ao desenvolver um aplicativo, você invariavelmente traz muitos pacotes Python úteis. Ao manter pacotes em um ambiente virtual específico do projeto, você pode atualizar facilmente o arquivo de requirements.txt do projeto que descreve esse ambiente, que está incluído no controle do código-fonte. Quando você copia o projeto para outros computadores, incluindo servidores de compilação, servidores de implantação e outros computadores de desenvolvimento, é fácil recriar o ambiente. Você pode recriar o ambiente usando apenas o arquivo requirements.txt, e é por isso que o ambiente não precisa estar no controle do código-fonte. Para obter mais informações, consulte Usar ambientes virtuais.

Remover ambiente virtual sob controle do código-fonte

Você pode remover um ambiente virtual depois que ele estiver sob controle do código-fonte. Siga estes passos:

1. Edite o arquivo de .gitignore do para excluir a pasta:

   1. Abra o arquivo selecionando Arquivo>Abrir>Arquivo.

      Também pode abrir o ficheiro a partir do Team Explorer. Na página de Configurações, selecione Configurações do Repositório. Vá para a seção Ignorar & Atributos e selecione o link Editar ao lado de .gitignore .

   2. Encontre a secção no final que tem o comentário # Python Tools for Visual Studio (PTVS).

   3. Depois dessa seção, adicione uma nova linha para a pasta do ambiente virtual, como /BasicProject/env.

2. Abra uma janela de comando e vá para a pasta (como BasicProject) que tem a pasta do ambiente virtual, como env.

3. Execute o comando git rm -r env para remover o ambiente virtual que está atualmente sob controle do código-fonte.

4. Com o comando git commit -m 'Remove venv', confirme as suas alterações, ou confirme-as na página Alterações do Team Explorer.

Examinar o código padrão

Nesta seção, você examina o código clichê no arquivo de projeto (.py) que o Visual Studio cria com base em sua seleção de modelo.

Observação

O código clichê é o mesmo se você criar o projeto no Visual Studio a partir do modelo Django ou gerar o projeto usando o comando django-admin startproject <project_name>CLI .

1. Abra Gerenciador de Soluções para exibir seus arquivos de solução e projeto. O projeto inicial contém apenas dois arquivos, manage.py e requirements.txt:

   

   O arquivo requirements.txt especifica as dependências do pacote Django. A presença desse arquivo é o que convida você a criar um ambiente virtual ao criar o projeto pela primeira vez.

   O arquivo manage.py é o utilitário administrativo de linha de comando Django que o Visual Studio define automaticamente como o arquivo de inicialização do projeto. Execute o utilitário na linha de comando utilizando o comando python manage.py <command> [options].

   Para tarefas comuns do Django, o Visual Studio fornece comandos de menu convenientes. Clique com o botão direito do mouse no projeto no Gerenciador de Soluções e selecione Python para ver a lista de comandos. Você usa vários desses comandos nesta série de tutoriais.

2. Além dos dois arquivos, o projeto também tem uma subpasta com o mesmo nome do projeto. Esta pasta contém os arquivos básicos do projeto Django:

   

   • __init__.py: Um arquivo vazio que informa ao Python que esta pasta é um pacote Python.
   • settings.py: As configurações para o projeto Django, que você modifica quando desenvolve um aplicativo Web.
   • urls.py: Um sumário para o projeto Django, que você modifica à medida que desenvolve seu aplicativo Web.
   • wsgi.py: Um ponto de entrada para servidores Web compatíveis com WSGI para servir o seu projeto. Você geralmente deixa esse arquivo as-is porque ele fornece os ganchos para servidores Web de produção.

Gerar requisitos após a instalação do pacote

Visual Studio pode gerar um arquivo de requirements.txt de um ambiente virtual depois de instalar outros pacotes.

• No Explorador de Soluções, expanda o nó Ambientes Python, clique com o botão direito do rato no seu ambiente virtual e selecione Gerar requirements.txt.

É uma boa prática usar esse comando periodicamente à medida que você modifica o ambiente. Confirme alterações no arquivo requirements.txt para controle do código-fonte junto com quaisquer outras alterações de código que dependam desse ambiente. Se você configurar a integração contínua em um servidor de compilação, deverá gerar o arquivo e confirmar alterações sempre que modificar o ambiente.

Executar o projeto

Agora você está pronto para executar seu projeto no Visual Studio seguindo este procedimento:

1. No Visual Studio, selecione Depurar>Iniciar a Depuração (F5) ou selecione do Servidor Web na barra de ferramentas principal (o navegador que você vê pode variar):

   

2. Qualquer comando executa o servidor usando o comando manage.py runserver <port>, que inicia o servidor web interno no Django.

   O código inicia o aplicativo usando a porta especificada dentro do servidor de desenvolvimento Django.

   Se o Visual Studio postar a mensagem Falha ao iniciar o depurador e indicar que nenhum arquivo de inicialização foi encontrado, clique com o botão direito do mouse no arquivo manage.py no Gerenciador de Soluções e selecione Definir como Arquivo de Inicialização.

3. Quando o servidor é iniciado, uma janela do console é aberta para exibir o log do servidor. O Visual Studio abre automaticamente um navegador para http://localhost:<port>. Como seu projeto Django não tem aplicativos, o Django mostra apenas uma página padrão para confirmar que o código atual está funcionando conforme o esperado.

   

4. Quando terminar, feche a janela do console, que interrompe o servidor de desenvolvimento Django. Você também pode selecionar Depurar>Parar Depuração.

Use o servidor web Django e framework

Django tem um servidor web embutido que você pode usar para fins de desenvolvimento. Quando você executa seu aplicativo web Django localmente, você usa o servidor de desenvolvimento web Django integrado. Um exemplo deste cenário é quando está a depurar a sua aplicação web Django no Visual Studio.

Quando você implanta seu aplicativo web Django em um host da web, você usa o servidor web no host em vez do servidor web Django integrado. O módulo wsgi.py no projeto Django cuida da conexão com os servidores de produção.

Compare os comandos Debug com os comandos Python do projeto,

Há uma diferença entre usar os comandos do menu Debug e os comandos do servidor listados no submenu Python do projeto.

Além dos comandos de menu Debug e botões da barra de ferramentas, você também pode iniciar o servidor usando os comandos Python>Start server ou Python>Start debug server no menu de contexto do projeto.

Ambos os comandos abrem uma janela do console na qual você vê a URL local (localhost:port) do servidor em execução. No entanto, você deve abrir manualmente um navegador com essa URL e executar o servidor de depuração não inicia automaticamente o depurador do Visual Studio. Você pode anexar um depurador ao processo em execução mais tarde, se desejar, usando o comando Debug>Attach to Process.

Próximo passo

Etapa 2: Criar um aplicativo Django com visualizações e modelos de página