Transcrições
1. Apresentação: Neste módulo,
veremos suas contas de armazenamento. Nesta segunda-feira,
vamos explorar as ofertas de contas de armazenamento
do Azure. Vamos analisar
Armazenamento de Blobs, Armazenamento de tabelas, Armazenamento em filas. E, por fim,
desenvolveremos uma solução que
interagirá com cada um desses
componentes do armazenamento do Azure. Então, como sempre,
vamos criar nosso armazenamento ou cones. Veja as diferentes opções , explore todas as nuances e explore como
você pode integrar essas ofertas em
nossas próprias soluções. Portanto, fique atento. Este
vai ser um módulo divertido.
2. Compreendendo o armazenamento de blob do Azure: Para começar,
vamos começar
analisando as ofertas de
armazenamento do Azure Blob. Agora, o Azure Blob Storage é
um serviço baseado em nuvem para armazenar dados não estruturados, como arquivos de
texto, imagens, vídeos, etc. É uma solução escalável, segura
e muito econômica para armazenar grandes
quantidades de dados. E oferece suporte a
recursos de segurança, como criptografia, autenticação
e autorização. Há integração embutida
para o Azure AD e seus dados serão
criptografados em movimento e em repouso. Os dados podem ser acessados por meio protocolos
HTTP ou HTTPS em
qualquer lugar do mundo, que os torna um
candidato adequado para coisas de CDN. Então, CBN, essas letras significam
Content Delivery Network. Então, devido a essa flexibilidade, Blob Storage é
perfeito para isso. Integrar ou criar
aplicativos para suportar a oferta de armazenamento Blob é muito fácil. Se você estiver
usando dotnet, Ruby Java, Python e várias
outras estruturas, você sempre pode verificar se a estrutura apropriada
existe para sua referência. Mas é claro que são as pontuações dos desenvolvedores do
dotnet e isso nos ajuda. Agora, ele é comumente usado para
cenários em que queremos exibir imagens ou documentos
diretamente no navegador. Precisamos facilitar o acesso
distribuído a
um conjunto de documentos. Se você quiser transmitir conteúdo
como vídeo e áudio, se quiser armazenar
arquivos de log e continuamente, diretamente, para esses arquivos de log. Ou se quisermos armazenar
dados para backup, recuperação de
desastres
e arquivamento. Saiba que, se você gosta de
ciência de dados e big data, perceberá que
existe uma oferta chamada Azure Data
Lake Storage Gen2, que é a solução
corporativa de análise de
big data da Microsoft para a nuvem. Isso oferece um sistema de arquivos
hierárquico, bem
como as vantagens
do armazenamento Blob. E essas vantagens incluem
o fato de ser de baixo custo, disponibilidade de armazenamento hierárquico, forte consistência e recursos de recuperação de
desastres. Agora, acabamos
de mencionar os níveis de armazenamento. Portanto, há três
tipos de camadas de armazenamento. A primeira que
analisamos, essa camada de armazenamento quente e
quente, é usada para analistas de dados
acessados com frequência. Você verá que são as opções
mais caras. Então, se você sabe que
está sempre acessando o armazenamento do Blob para
acessar esse arquivo, talvez vídeos que
estão sendo transmitidos, áudio que está sendo transmitido. Então você gostaria que ele ficasse
no nível de armazenamento quente. Depois, temos o nível de armazenamento
frio, que é usado para dados acessados
com menos frequência. E, claro, é um pouco mais
barato do que o popular, porque o tráfego
não existe em relação
ao arquivo ou arquivos. Portanto, sempre que você
tentar acessar um arquivo, pode
demorar um pouco
mais para carregar o arquivo. Mas é claro que isso é
melhor para arquivos que devem ser
armazenados a longo prazo e com os quais não interagem tanto. Depois, temos a camada de
arquivamento, que é para dados
raramente acessados. Portanto, isso é para arquivos
que, em geral, as organizações
precisam manter arquivos ou manter registros por
até sete anos. Tudo bem, então você gostaria de
arquivar arquivos, talvez depois do terceiro ano você possa
colocá-los no
armazenamento de arquivos porque você não os
acessará tanto. E se você acessar, vai levar muito mais tempo. Terá que reidratar
esse arquivo ou bolha depois o traria de volta. Então, é claro, isso é
usado para
backups estendidos e é a opção mais
barata. Agora, um armazenamento em dois pontos tem pelo
menos dois componentes principais que você vê em todos
os outros tipos de armazenamento. Mas já que estamos
falando sobre bolhas, vou meio que adaptar a
inflamação em relação às bolhas. A primeira coisa que você tem
são as contas reais. Agora, isso fornece um namespace no Azure para seus dados
e cada objeto que eu uso armazenado no Armazenamento do Azure
teria um endereço que inclui esse nome de
conta exclusivo. Em seguida, temos o contêiner e nosso contêiner organiza
todos os blobs mesma forma que você esperaria que um sistema de arquivos como Windows ou Linux
organizasse seus arquivos. Você tem esse tipo de
hierarquia de estrutura de pastas disponível para você em nosso contêiner. Em seguida, o blob representa
um arquivo físico que é armazenado dentro
do contêiner. Há um diagrama
mostrando essa hierarquia. Vários tipos de bolhas são. Blob é um blob, quero dizer, é um arquivo armazenado
nesse armazenamento ou cones, mas diferentes
bolhas precisam ser tratadas de forma diferente
por diferentes motivos. Portanto, a primeira
que temos é uma bolha de bloco, que provavelmente é
a mais comum. Usamos isso para armazenar
texto ou dados binários. E é composto por
blocos de dados que podem armazenar até 190,7 trilobitas,
não terror, mas bytes de Tilly. Em seguida, acrescentamos bolhas. Agora, isso tem blocos
semelhantes aos blobs de blocos. Bem, eles são otimizados
para a operação de anexação. Portanto, isso seria ideal para um cenário em que
precisamos registrar dados de uma máquina virtual
ou em seu serviço de aplicativos. Se você se lembra, quando estamos registrando o App Service, poderíamos ter optado por fazer
login em um blob, certo? Então, isso é o que usaríamos. Isso forneceria um Append
Blob para essa situação. O próximo tipo
seria bolhas de página. Os blobs de página armazenam
arquivos de acesso aleatório de até 8 kb de tamanho e geralmente são usados como arquivos de disco rígido
virtual para nossas
máquinas virtuais no Azure. A seguir, vamos ver
como seu armazenamento de mesa.
3. Compreendendo tabela e armazenamento de fila: Agora, seu armazenamento de tabelas
é um serviço que armazena dados não relacionais
ou não estruturados, também conhecido como SQL. E é um
serviço de nuvem, mais uma vez, que nos fornece armazenamento de
atributos essenciais em um design sem esquema. Agora, você teria
visto referenciado como seu armazenamento de tabela quando
analisamos outro Cosmos DB. E é uma das APIs suportadas
pelo Azure Cosmos DB. Portanto, se você começar com tabelas de armazenamento
do Azure ou
, em vez disso,
com o Armazenamento precisar migrar para e precisar migrar para
obter
mais armazenamento e mais redundância, poderá
passar para o Cosmos DB. Mas esse é um excelente
lugar para começar. Se você não tem certeza de suas necessidades de
dados e precisa ser capaz de se adaptar aos novos
requisitos ou detalhes
, essa é uma
excelente solução para começar,
pois não contém esquemas e,
portanto, sempre poderá
evoluir de acordo com suas necessidades. Agora, o acesso é rápido e econômico e geralmente
é
menor do que outras ofertas de SQL para volumes de dados
semelhantes. Você também pode considerar que,
se quiser
começar com nossa Instância SQL relacional
ou do Azure e souber que
não armazenará tantos dados antecipadamente, você pode começar
com tabelas e depois subir. Mas é claro que todas
essas coisas
afetarão suas decisões. O próximo tipo de armazenamento que
temos é como armazenamento em fila. Agora, esse é um
serviço para armazenar grande número de mensagens. Essas mensagens podem ser
acessadas em qualquer lugar por meio chamadas
autenticadas
via HTTP ou HTTPS. Essencialmente, ao
configurar seu armazenamento em fila, você receberá um link que permite que você se inscreva no armazenamento e leia e
escreva mensagens fora da fila. A mensagem da fila pode ter
até 64 kb de tamanho. E você pode receber o maior
número
possível de mensagens com base
no limite
de capacidade do seu armazenamento ou cones. Saiba em geral, pois suas dicas, armazenamento ou filas em geral são usadas para criar um
acúmulo de itens de trabalho. O processo de forma assíncrona. Isso significa que,
digamos que, se você estiver criando um aplicativo que
precisa enviar um e-mail, você deseja que o aplicativo pause enquanto você se conecta
ao servidor de e-mail, descubra o conteúdo do envio de e-mail, do e-mail, espere para ver se ele foi
bem-sucedido, o despachado
e, em seguida, o usuário pode
continuar, talvez não. Portanto, o IQ permitiria
que você entregasse essas informações e prosseguisse com
sua inscrição. E então você teria
outro serviço que provavelmente tiraria
essa mensagem da fila e enviaria
o e-mail eventualmente para que nós, a experiência do usuário,
não fosse afetada. E isso é apenas um exemplo. As filas podem ser usadas
de várias maneiras, especialmente se você estiver falando
sobre microsserviços. Mas vamos dar alguns
exemplos
com essas coisas. Então, nos vemos na próxima
lição, onde começaremos.
4. Criar uma conta de armazenamento do Azure: Agora, em nosso portal,
vamos
criar uma nova conta de armazenamento. Então, vamos direto ao assunto. Vamos examinar nossas pílulas e escolher
Criar um recurso. E a partir daqui, vamos
procurar armazenamento. Então, eu posso simplesmente digitar armazenamento, pressionar Enter e ok, bem, vamos usar a conta de armazenamento de
preenchimento automático. Queremos um armazenamento de cones, então vamos selecionar isso
e criar a partir daqui, vamos preencher
ou formar como de costume. Então, como esse armazenamento é um serviço gerenciado pela
Microsoft que inclui dados de armazenamento de blob,
Lake Gen2, azure Files. Nós realmente não falamos
sobre o Azure Files, mas vou explicar isso um pouco. Filas e tabelas. Não, é importante que você acerte essas configurações
porque algumas coisas estarão disponíveis com base em
seu nível e com base
no tipo de conta de armazenamento
que você provisiona. Portanto, a primeira coisa
, como de costume, é
selecionar o grupo de recursos do carrinho. Então, vamos seguir em frente e fazer isso. E então, para o nome do armazenamento, direi que,
como você é cavalo, é claro que vou escolher
a melhor zona com base nas
minhas necessidades de soluções. E então podemos
escolher uma performance. Então, queremos o padrão, que
é o recomendado, ou queremos o premium,
que consiste em quatro cenários
que precisam de latência muito baixa. Portanto, para esta demonstração, manteremos o padrão. Obviamente, se você
tiver outras necessidades, escolha a
que é apropriada. Também pela redundância. Eu só vou escolher
localmente redundante. E redundância, algo
que você também deve sempre considerar em cada serviço
novamente, com base em suas necessidades. Então, vou escolher o armazenamento localmente
redundante. Vá para a próxima opção. Vou deixar tudo o
que foi marcado, vou deixar marcado. E então, se estivéssemos fazendo algumas operações de big data, poderíamos escolher
um Data Lake Gen2 para namespace
hierárquico
é
que um Data Lake Gen2 para não estamos fazendo nenhuma operação de big data, então vou deixar isso de lado. E então, quando rolamos
para baixo, podemos ver aqui se queremos o calor ou o frio? Portanto, lembre-se das teclas de atalho para cenários de uso
diário acessados
com frequência. Talvez como o CDN. Talvez seja aí que toda
a organização armazena arquivos,
lê e escreve. Em vez do armazenamento frio, que provavelmente é onde
você colocaria arquivos que são acessados de
vez em quando. Tudo bem. Depois,
temos os arquivos do Azure. Assim, seus arquivos
são uma provisão
da conta de armazenamento
que nos fornece um
compartilhamento de arquivos totalmente gerenciado na nuvem. E eles são acessíveis
por meio de padrões do setor, protocolos
Server Message Block
ou SMB, sistema de arquivos de
rede
ou protocolos NFS ou até mesmo apenas uma API RESTful. Em um inglês mais simples. Como seus arquivos seriam como
um compartilhamento de arquivos na nuvem que você poderia configurar
para que sua organização substituísse a distorção local. Então, como não estamos
facilitando compartilhamentos de arquivos, não
permitirei nem
habilitarei compartilhamentos de arquivos grandes. E então podemos passar para a rede e tudo o que
existe, a falha está bem. Proteção de dados. Então, aqui podemos configurar opções
de como lidamos com os dados. Vou deixar os
padrões marcados, mas encorajo você a
ler cada um deles apenas para ver o que está dizendo e alterar esses valores com
base nas necessidades de urina. É claro. Também podemos ativar o
rastreamento de versões para nossos blobs. Se você tiver vários arquivos, várias versões de um arquivo, ele manterá esse log. E você pode ativar um
feed de alterações caso tenha algum serviço que precise
se inscrever no estado do blob.
Ok, bem, essa alteração, eu preciso acionar uma ação. Então, essas são coisas que você pode considerar se
quiser automatizar alguns outros fluxos de trabalho com base
nos blobs e nas atividades
realizadas em seus blobs. Agora, quando
passamos para a criptografia, mencionei
anteriormente que os dados são criptografados em repouso
e em trânsito. Então, eles estão apenas mostrando
o tipo de criptografia. Vou deixar os padrões
lá e, em seguida, poderemos escolher quais serviços oferecem suporte às chaves gerenciadas pelo
cliente, e vou deixá-los como padrão. Então, mais uma vez
, seriam nossas etiquetas. O que? Vou
passar para revisar. E depois que a análise for
concluída com êxito, podemos prosseguir e criar
nossa conta de armazenamento. Quando a implantação estiver concluída, podemos clicar em Ir para o recurso. E quando estivermos lá, veremos que nossa conta de armazenamento
ou armazenamento de blobs foi criada. E a partir daqui podemos
fazer várias coisas. Então, quando
voltarmos, exploraremos quais são as diferentes
opções podem interagir com os diferentes componentes
de nossa conta de armazenamento.
5. Emulador de armazenamento do Azure: Agora, vale a pena mencionar
que temos acesso a um emulador local
para armazenamento do Azure, chamado azurite. E isso é de código aberto
e multiplataforma. Portanto, você tem várias opções de
instalação
e verá aqui que ela fornece suporte
multiplataforma no Windows, Linux e macOS. E nos permite acesso local
gratuito a um ambiente para
testar armazenamento de blob, armazenamento filas e armazenamento em
tabelas. Então, todas as atividades que estamos prestes a realizar envolvendo todos esses serviços,
poderíamos realmente realizar se implementássemos nossa provisão, esse emulador local
para esses serviços. Agora, configurar os serviços
é relativamente fácil. Se você estiver usando o
Visual Studio 2022
, você o obtém automaticamente. Se você estiver usando o
Visual Studio Code, você pode obtê-lo para extensões. Se você estiver usando o npm, você pode executar um comando se
estiver usando algo mais escuro do que você pode extrair essa
imagem e instalar. E você sempre pode ir diretamente
para o repositório azurite Git, repo e cloná-lo. E para executá-lo, você
tem várias maneiras interagir com o azurite se
estiver usando o
Visual Studio, o visual Studio Code, etc. Portanto, você pode ler
esta documentação se
quiser apenas configurar um
ambiente local. E então você pode ir
em frente e acessá-los. Saiba que vamos explorar
o Explorador de Armazenamento um pouco mais de detalhes à medida que
esse módulo avança. Mas eu só queria
ressaltar isso para acessar o ambiente local e simular interações
com cada um
dos diferentes componentes
de uma conta de armazenamento.
6. Gerenciamento de conta de armazenamento: Portanto, neste
painel, você pode ver que várias opções
que talvez não tenhamos habilitado ou habilitado
e que provavelmente queríamos desabilitá-las posteriormente estão
disponíveis para alteração aqui. Então, se eu quisesse mudar a
camada de acesso padrão de quente para fria, eu poderia facilmente clicar nela e depois mudar isso. Certas coisas não podem ser alteradas
ou você pode simplesmente mudar
o desempenho
do padrão para o premium. Mas você pode mudar
algumas outras opções. Então, mais tarde, ele decidiu ou a organização decidiu
que precisava permitir arquivos grandes. E você verá aqui
que ele suporta armazenamento
rápido de até 100 kb. Você poderia ir em frente e fazer isso. Também poderia alterar essas cotações de
ações aqui, mas vamos deixar isso quente por enquanto. Posteriormente, podemos
remover o recurso ou reduzi-lo para um nível legal. Agora, de volta ao nosso painel de visão geral, vemos que temos a opção de
abrir em um explorador. Se clicarmos em Open Explorer, você verá que é
algo que você pode baixar e que permitirá gerenciar seus arquivos,
seus contêineres e tudo
do seu computador. Também podemos usar um navegador
de armazenamento. Assim, podemos clicar no navegador
de armazenamento e
isso nos levará a interface bastante
semelhante que nos
mostra o número
de contêineres, compartilhamentos de
arquivos, tabelas e
filas no sistema. Também podemos prosseguir e
interromper com esses componentes. Então, eu posso ir em frente e criar
um novo contêiner aqui. E eu vou chamar esse contêiner. É claro que é um contêiner. Posso definir o
nível de acesso se eu quiser que ele seja privado para que ninguém mais acesse, ou blob
para acesso de leitura
somente para blobs ou contêiner com acesso somente para blobs ou contêiner com anônimo de leitura e gravação
para blobs e blobs contínuos. Agora deixe isso como privado. E, de forma avançada, posso definir o escopo da criptografia e o suporte à
imutabilidade. Vou seguir em frente
e clicar em Criar. Agora, uma vez que esse blob tenha sido criado ou aquele contêiner seja outro, posso ir até o
contêiner e adicionar um diretório ou fazer o upload de um arquivo. Agora lembre-se de que o
contêiner é onde os arquivos realmente vão
e tenta
fornecer uma
visão hierárquica dos arquivos e, se necessário, a visualização entre
aspas de pastas ou
diretórios. Assim, posso adicionar um diretório e
chamá-lo de novo diretório. Você, é uma árvore grossa? Lá vamos nós. Então, dentro desse diretório
improvisado, posso realmente somar todos os diretórios, se
quiser, ou posso simplesmente fazer o upload. Portanto, ao fazer o upload,
posso optar por substituir se, como já existe, posso arrastar e soltar
ou procurar arquivos. E então, quando
olho para o avançado, posso escolher o tipo de
blob que estou enviando. Portanto, há um blob de bloco, Page Blob ou Append Blob. Eu geralmente não mudo isso porque, na verdade, só faço
upload de blobs de blocos. Ou você pode escolher o tamanho do bloco se
quiser acessar estereótipos. Então, se estiver quente, legal ou arquivado, e pudermos fazer o upload de uma pasta, podemos fazer várias coisas. Então, vou
fazer um upload simples. E estou apenas enviando um PDF aleatório que
encontrei no meu computador. Nada muito chique.
E aí está. Acabei de enviar meu primeiro
arquivo Blob e ele está em alta. Claro, eu posso ir
em frente e editá-lo. Eu posso obter um URL, posso gerar um token SAS. E vamos
analisar tudo e o que eles significam. E eu posso até deletar. Agora lembre-se de que isso
ativou a exclusão reversível. Se eu excluir isso, posso realmente voltar e mostrar bolhas
ativas e excluídas, o que
trará de volta tudo o
que eu excluí. Isso me
mostrará e estava me
mostrando por quanto tempo
está sendo retido. E então adivinha? Na verdade, não posso excluí-lo. Se eu clicar com o botão direito, posso clicar em Excluir e ele será restaurado. Então, isso é uma boa
segurança se removermos acidentalmente algum arquivo. Não, lembre-se de que compartilhamentos rápidos
exigirão um pouco mais de
finalização na configuração, mas é uma
excelente maneira de mover seu compartilhamento de
arquivos do computador local ou fáscia de
sua organização dos servidores locais e
colocá-los na nuvem. E isso é especialmente
útil para países que exigem acesso distribuído
ao mesmo conjunto de arquivos. Tudo bem, então, se você quiser
um compartilhamento de arquivos privado para nossa configuração distribuída com
redundâncias em vigor, essa é uma excelente
opção para você. Vamos passar às dicas. Apesar. Fui adicionar uma nova fila e vou chamar
isso de cavalo. P: Vamos prosseguir e clicar em OK. Em seguida, você verá
o corpo do URL. Então,
quando estivermos fazendo o desenvolvimento,
vamos dar uma olhada quando estivermos fazendo o desenvolvimento, na URL do nosso contêiner Blob,
dos blobs e tudo mais. Mas, no momento, estamos apenas fazendo uma visão geral da conta
de armazenamento. Então, a partir desse URL da fila, eu posso realmente me
inscrever nessa distorção e colocar mensagens
na fila. Eu posso ler mensagens
fora da fila agora e dizemos que mensagem é o que
exatamente queremos dizer? Quando seleciono a fila, posso clicar em Adicionar mensagem. Então, se eu adicionar uma mensagem
e disser que esta é uma mensagem de teste aleatória. E eu posso definir um período de
tempo, ele deve expirar. E assim, em sete dias, se essa mensagem não for
processada, remova-a. É claro que, mais uma vez, suas necessidades serão diferentes, então você escolhe a que é apropriada para o que você precisa. Você também pode ver que a
mensagem sempre expirou,
então, quando uma mensagem estiver
igual a Q, nunca a exclua até que
seja processada. Tudo bem? E então você diria codificar, gostaríamos de fazer isso. Vou clicar. Ok. Então, quando eu clico em OK, agora
temos uma mensagem
na fila. E mais uma vez, quando
dizemos mensagens, estamos falando sobre dados
que precisam ser processados. Então, essa mensagem, como você pode ver, é realmente apenas texto. E eu adicionei acidentalmente
a mesma mensagem duas vezes. Na verdade, basta, tudo bem, então isso significa que isso
pode ser uma frase. Pode ser algum tesouro. Pode até ser um objeto JSON, que é uma forma muito popular de transportar dados como
corpos de dados em pistas. Então, o que poderia acontecer aqui
é que você poderia enviar um bloco de objetos JSON e
JSON como bastões. E então você pode usar um serviço de terceiros ou outro serviço para realmente
processar essa mensagem JSON, que terá todas
as informações necessárias para uma operação em mãos. Várias coisas e várias
maneiras de usar dicas. Mais uma vez, o
principal uso das filas é descarregar processos que podem causar
atrasos no tempo real de execução dos aplicativos. Portanto, é mais rápido usar
o exemplo de e-mail novamente, é mais rápido
entregar o corpo do e-mail,
que poderia ter sido
esse objeto JSON com o remetente para os endereços de
e-mail do destinatário e, em seguida o corpo da mensagem
e tudo o mais estava na fila e depois continuar
com o aplicativo. E então, em segundo
plano, essa mensagem
será retirada da
fila e enviada. Quando digo ventralmente, quero
dizer, isso pode acontecer. Veja, ao mesmo tempo, isso
pode acontecer 20 e-mails depois, se você tiver centenas de usuários enviando e-mails
no sistema, você não quer centenas de usuários e aquele que
está esperando pelo sistema. Vamos ver alguns exemplos de várias
maneiras Vamos ver alguns exemplos de no restante deste curso. Então, isso é tudo o que adicionamos
mensagens à fila. E, claro, podemos
limpar a fila e também
podemos enviar mensagens. Então, eu poderia clicar nesta
mensagem e dizer dq. Agora, a próxima
seriam as mesas. O armazenamento de tabelas, mais uma vez,
é um design sem esquema. Então, eu posso clicar em Adicionar
tabela e dar um nome a ela. E onde quer que você
me veja sem usar traços, porque certos serviços têm convenções de nomenclatura
mais rígidas e outros, então alguns deles
permitem os hífens, não. Então você descobrirá isso
à medida que avança. Ele sempre avisará
você quando
estiver violando a convenção de
nomenclatura. Mas quando eu clico em OK, isso cria uma nova tabela. E, mais uma vez, obtemos um URL para essa
tabela, onde podemos nos
inscrever
e ler dados da tabela. E então, se eu clicar
no recurso em si, teremos um layout muito semelhante ao que vimos quando usamos
o Azure Cosmos DB. Temos chaves de partição, temos chaves de linha e elas terão um registro de data e hora. Então, basicamente, quando
clico em Adicionar entidade, tenho a opção de fornecer uma chave de
partição e uma chave de linha e posso adicionar outras
propriedades de acordo. Tudo bem, então vamos adicionar
uma nova entidade. Agora, digamos que eu queria
armazenar alguns itens de mercearia. E o que vou fazer
aqui é verificar se a chave de partição é a
categoria do produto. Então, se eu estiver armazenando
algo que é laticínios, a propriedade
número um, digamos, é o preço. E então eu posso
escolher o tipo de dados. Portanto, o preço seria o dobro. Digamos que custe $2,50. E então o próximo
seria o nome do item. Não sei por que coloquei a
prensa antes do nome, mas digamos
que isso é leite. E depois insira. Agora, eu poderia ter
gerado uma nova chave de linha. Eu poderia ter colocado um arco
que teria usado um GUID. Intencionalmente, deixei em branco, mas estou apenas mostrando
os pontos em que podemos inserir nossa chave de partição e
chave de linha, mas depois podemos inserir quantas outras colunas e pares de valores de coluna forem
pares de atributos-chave do par de
valores-chave quanto
precisarmos e, como dissemos,
conforme suas necessidades aumentarem . Então, novamente, os dados para que eu possa adicionar outra entidade
que talvez mais
tarde eu tenha percebido que preciso
armazenar mais propriedades do que apenas preço e nome, certo? Então, se desta vez
foi, digamos, grampo, e então vamos dar uma chave de
linha, desta vez uma. E então o preço é dez. Digamos que o
nome seja pão. E o que mais
precisaríamos para armazenar isso? Talvez eu queira que ele realmente seja
colocado em uma categoria. Mais uma vez, isso é um grampo. Talvez a data de validade. Só estou
inventando as coisas da maneira certa. Porque, mais uma vez,
suas necessidades serão diferentes. A data de validade tem
a hora, certo? Então você escolhe o valor de
dados apropriado e, em seguida, eu coloco uma data de validade e
excluo o último. Então, digamos que
esse fosse um novo visual. À medida que nossas necessidades aumentam, o número de colunas que
podemos colocar aumentará, r pode aumentar com muito
poucas consequências. E é daí que vem esse aspecto de nenhuma
sequência. Portanto, ainda parece relacional, mas ainda temos a vantagem do design de listas de esquemas. Agora, isso completa nosso tour pela
nossa conta de armazenamento. Quando voltarmos, veremos como podemos criar soluções que interajam com esses
diferentes componentes.
7. Explorer de armazenamento: Agora, se você optar por usar
o Storage Explorer, obterá aquele visual de
barra de código do Visual Studio, desculpe, como seu Data
Studio parece. Então, antes de tudo, você pode querer gerenciar nossos cones e
autenticar adequadamente. E depois de autenticado, você pode detalhar
seu armazenamento ou cones. Então, depois de
resolver sua autenticação, você poderá acessar as diferentes partes. Então, aqui está a conta de armazenamento
que criamos anteriormente. E, mais uma vez,
podemos nos
aprofundar e analisar
diferentes compartilhamentos de arquivos , dicas, tabelas , dicas, tabelas e
todos esses recursos que
examinamos anteriormente. Você pode até ver alguns
outros que não viu no navegador Explorer. Então você pode ir em frente e fazer isso. E todas as
opções que você tinha no navegador também estão
disponíveis aqui. Assim, você pode realmente
gerenciar seus arquivos, seus blobs, suas pastas,
tudo aqui. E isso é ainda melhor para o
gerenciamento de máquina a máquina do Blob Storage. Então, acho que adquirir o Storage Explorer
é uma ideia muito boa. E isso torna o gerenciamento
do armazenamento de cones muito mais fácil do que
ter que acessar o
navegador todas as vezes.
8. Visão geral de aplicativos na Web: Agora vamos desenvolver um aplicativo
web que é quando você usa os diferentes componentes fornecidos pelo armazenamento ou pelos cones. Portanto, nossa ideia de projeto web
foi fornecer um formulário de inscrição
para os participantes da conferência. Vamos usar asp.net, MVC. Desta vez
usamos as páginas do Razor, você usou o blazer,
vamos usar o MVC. Mas, mais uma vez, quando
for dotnet Core, os conceitos
serão transferíveis. Saiba o que vamos fazer
é usar o Armazenamento de Tabelas do Azure para armazenar o registro
e clicar em Enviar. Vamos armazenar
esses dados nesse armazenamento de tabelas. Vamos permitir que
eles façam upload de uma imagem. Nesse upload de imagem,
usaremos o Azure Blob Storage. Ok, então normalmente você o
armazenaria localmente, mas não queremos que seja armazenado
localmente no servidor. Vamos descarregar
isso como seu armazenamento de Blob. Vamos usar o
Azure Queue storage porque queremos
enviar um e-mail. Então, usei esse
exemplo anteriormente
neste segmento do curso. Estamos enviando um e-mail
que exige que
o computador congele, faça isso e siga em frente. Então, vamos simplesmente
entregá-lo para a fila. Em seguida, criaremos um aplicativo de console que
simulará um cliente que
leria a fila e
processaria a mensagem ou os dados de e-mail da
fila para envio. Então, vamos fazer todas
essas coisas no futuro.
9. Criar e configurar . Projeto de núcleo do NET: Então, usando a mesma
solução
que usamos durante
todo o curso, eu queria criar
um novo projeto. Obviamente, isso é opcional. Se você quiser separar cada
um em sua própria solução, pode
seguir em frente. E mais uma vez, estou
usando o Visual Studio. Você também pode acompanhar se
estiver usando o Visual Studio Code. Então vá em frente e
crie um novo projeto. E desta vez vou
usar um aplicativo web MVC. Então, vou
digitar as letras MVC na pesquisa e escolher ASP Core Web com Model View Controller. Em seguida, vou chamar isso de demonstração de uma
conta de armazenamento MVC. Em seguida, tudo pode
permanecer como padrão. E então criamos, se você estiver usando a
terminologia Visual Studio no
Linux ou Mac OS, você pode ir em frente e navegar
até o diretório desejado. E então você pode dizer
dotnet, novo MVC. E então você pode enviá-lo para um diretório com o
nome do projeto. E então você pode ir
em frente e pressionar Enter. Agora que o projeto
foi criado, vamos adicionar algumas das bibliotecas com as quais
precisaremos trabalhar. E, claro, conhecemos as diferentes maneiras pelas quais
podemos adicionar bibliotecas. Mas vou
usar apenas os terminais, pois
o terminal
funcionará para todos, esteja você no código do Visual
Studio ou do Visual Studio. Então, vou dizer que dotnet adiciona pacotes ou, em vez disso, adiciona pacote. E então o primeiro
pacote que estamos adicionando é o Azure Storage Blobs. Então, podemos simplesmente pressionar Enter. Tudo bem, e depois que isso
for inserido com sucesso, vou limpar a tela. E então, desta vez, estamos adicionando filas de armazenamento de zero pontos. E, finalmente,
vamos adicionar tabelas de pontos
de dados com zero ponto. Tudo bem, então dotnet adicione o pacote
como suas tabelas de pontos de dados. Agora que temos
todas essas configurações,
vamos adicionar nossa cadeia de conexão de armazenamento, cadeia
de conexão de
armazenamento ou cadeia de
conexão de dois pontos. Vou passar para as configurações
do aplicativo, Jason, deixe-me ocultá-lo, o terminal para que possamos comprar
mais imóveis. E eu vou chamar essa cadeia de conexão de armazenamento. E então o valor da nossa cadeia de conexão
de armazenamento virá
do nosso portal. Então, vamos pular
para o nosso portal. E então pulamos
até o sangramento das chaves de acesso. E então vamos
selecionar a cadeia de conexão. Então, vou mostrar
Copiar para a área de transferência, voltar ao nosso código e depois colá-lo. Dentro. Lá vamos nós. Então, minha prancheta ainda
não estava pronta. Então essa é a nossa cadeia de
conexão. E eu vou
criar uma nova pasta. E essa nova pasta
armazenará nosso modelo de dados para
as tabelas de armazenamento. Então, vou chamá-lo apenas de dados. De acordo com nossa convenção
de nomenclatura
já estabelecida, vamos adicionar uma nova classe. E eu vou
ligar para esse participante. Saiba que, como vamos
usar o armazenamento de tabelas, precisamos seguir em frente
e implementar a interface da entidade de TI. Portanto, os participantes herdarão imediatamente da entidade i table. E isso vem da
nossa classe de tabelas de dados. E então, usando pontos de controle, posso implementar a interface. Então isso agora nos dá essas colunas
específicas, certo? Lembre-se de que essas
colunas estavam lá antes de começarmos a adicionar
outros atributos. Tudo bem, então é claro que eu
posso simplesmente limpar isso e deixar que eles peguem B que eu
recebo e o conjunto, pronto. E remova tudo isso por meio de novas exceções
implementadas. Tudo bem, então, depois de
limparmos isso, vamos adicionar
nossas próprias propriedades. Então isso está me ajudando aqui. Então, eu tenho um nome e provavelmente
gostaria que o primeiro nome fosse
separado do sobrenome. E vamos colocar
um endereço de e-mail. E o que mais você
precisaria saber sobre o participante? Vamos trabalhar com isso por enquanto. Portanto, conforme nossos requisitos, cms significará colocar mais. Mas vamos começar com isso.
10. Adicionar serviço de armazenamento de mesa: Agora vamos configurar nosso serviço de armazenamento de
tabelas. Então, vou
criar uma nova pasta e chamá-la
de serviços. E aqui eu vou
criar uma nova turma. E essa classe será
chamada de Serviço de Armazenamento de Tabelas. E enquanto eu estiver aqui, vou fazer um ajuste
rápido aqui. Acho que vou
qualificar isso um pouco e chamá-lo de entidade participante. Só para não serem
só esses dez dias são apenas meus
pequenos ajustes. Se você sentir a necessidade de fazer
isso também, faça isso. Estou apenas renomeando-o aqui e
renomeando
o arquivo para atender à entidade alma de
nossos métodos aqui, eu vou ter, e vou escrever
para o público. Desculpe, vou escrever
todos os nomes dos métodos primeiro e depois
preencheremos os espaços em branco. Então, fui realizar uma tarefa
que retornaria a entidade
participante. E essa tarefa
será chamada de obter participantes. Tudo bem? E será necessário um ID de sequência de identificação porque pretendo
usar produtos para o
ID. Bons valores. Então, faremos com que um bom
participante receba participantes, o que usará
um parâmetro antigo. E então isso retornará uma
lista das entidades participantes. E depois mais dois métodos, um para atualizar e outro para excluir. Portanto, entre esses métodos,
temos a funcionalidade completa do crud. Vou apenas extrair
isso em uma interface para que tenhamos essa abstração
e essa herança. Lá vamos nós. Agora, podemos começar
a conectar isso. Então, vou criar
um construtor CT OR e Tab duas vezes, degenerar
esse construtor. E vou injetar meu objeto de configuração de
ícones nesse serviço para que
possamos ter acesso a esse arquivo de configuração
e aos valores nele contidos. Deixe-me renomear isso. Também vou
ter uma string privada, digamos const,
para o nome da nossa tabela. E eu vou
ligar para esses participantes. Tudo bem, então é assim que
vamos chamar
a mesa em nosso depósito de mesas. E nós temos a configuração. Agora eu preciso de um cliente. Tudo bem, então eu vou
criar um método, vou torná-lo um
método privado aqui embaixo. Portanto, tarefa privada que
retornará um objeto cliente de tabela. Tudo bem? E, claro, à medida que avança, você adiciona as instruções de
uso que faltam. Vamos dizer,
pegue um cliente de mesa. E esse cliente
primeiro definirá um cliente, estou apenas ligando para o cliente. Esse cliente
será igual à nova tabela. Bem, na verdade, este
é um cliente de serviço. Desculpe, estou renomeando
isso para cliente de serviço. Portanto, este é um novo cliente
de serviço de mesa. Lá vamos nós. Em seguida, vamos passar
esse valor de configuração para nossa cadeia de conexão. E caso você
não se lembre da chave, você sempre pode
voltar para cá. Não me lembro o quanto foi
pular aqui para pegá-la. E é isso que
vamos
usar para o valor da chave
de configuração. Tudo bem, agora que
temos o cliente de serviço, vamos salvar
nossa tabela.
O cliente será igual
aos clientes do serviço. Os pontos obtêm a tabela, o
cliente da tabela por meio do nome da tabela. O nome da tabela é o mesmo valor que
acabamos de armazenar aqui em cima. Então, podemos fazer isso. Então, vamos
aguardar a criação de uma tabela que
os clientes criem, caso ela não exista. Então, veja esse nulo. Se a tabela não existir quando estamos tentando comunicar com nossa conta
de armazenamento, temos a opção de simplesmente
criar, caso ela não exista. Então, eu posso simplesmente escolher isso. E, claro, vou escolher a opção assíncrona e então poderemos retornar
o cliente da tabela. Portanto, se a tabela não existir
, ela a
criará e se conectará a ela. E então nosso cliente agora incorpora
esse objeto de conexão. Então, vamos descobrir
tudo o que estamos fazendo isso. Receba o participante por ID. Agora, aqui teremos que
obter uma instância de cliente instável
e, em seguida, vamos
prosseguir e obter o Entity Sync? Sabe, parece assim. E, claro, se estamos esperando então o metil
e deve ser assíncrono. Portanto, var table client
é igual a dois. Faríamos com que o cliente da tabela escolhesse
o método que acabamos de criar. E então a segunda linha
que você percebe tem um erro. Então, é sincronizar a entidade e todos colocam o
ID e temos um erro. Por que temos um erro? Porque requer
uma chave de partição. Tudo bem? Portanto, temos que fornecer
uma chave de partição e uma chave de linha
para obter a entidade. Portanto, a entidade participante não tem nenhum
valor de chave de partição aqui, certo? Quero dizer, sim, temos o campo embutido
para uma chave de partição, mas não temos
um campo dedicado que atuará como
nossa chave de partição. Então, como parte de um bom design, nós realmente
lhe daríamos outra propriedade. E vamos ver se
cada participante de nossa conferência seria profissional em um determinado
setor, por exemplo. Então, o que podemos fazer
aqui é dizer indústria, vamos chamá-la apenas pelo nome do setor em
que você está, seja TI,
educação, etc. E então, a indústria aqui pode ser nossa chave
de partição para dividir todos os participantes
pelo setor. Faz sentido, certo? Portanto, ao criar seu
aplicativo para sua finalidade, você sempre quer
ter certeza de que está tomando as melhores decisões possíveis para sua indústria de design: aqui
estarão as chaves de partição. Então, voltando ao nosso método,
o que farei é transmitir a indústria de strings e o ID da string. E então passaremos o
setor e o documento de identidade para ir em frente e
buscar o participante. Para o próximo método, que é conseguir participantes. É claro que começamos
com o cliente de tabela e, em seguida, vamos fazer alguns
trechos de código diferentes aqui. Então, eu vou dizer tabela de páginas. Eu acho que o objeto de entidade chamado
entidades participantes
será igual à tabela Entidade participante da consulta de
pontos do cliente. E então podemos retornar a lista D2 de entidades
participantes, e isso
satisfará esse tipo de devolução. Agora vamos dar uma olhada no nosso absurdo. Como de costume, começamos com nosso objeto cliente de pesca ou
mesa. E se esperarmos, o método deve ser uma pia. E então vamos
aguardar nossa mesa, os pontos do cliente. Deixe-me tentar isso de novo. Então, oh, me desculpe. Isso é assíncrono. Aguarde o cliente da mesa. Lá vamos nós. Não perturbe a entidade assíncrona. Vamos seguir em frente e dar a
ele a entidade participante. Então, já vimos o hold upsert
funcionar quando estávamos fazendo o Azure Cosmos,
caso você não esteja tão
familiarizado com ele. Absurdo é basicamente
uma junção ou uma combinação das
palavras atualizar e inserir. Portanto, se a entidade existir com base nas
informações fornecidas, especialmente com a
chave e a chave de partição
, ela apenas
substituirá os detalhes. Se não existir, ele
criará o novo registro. Tudo bem, então
toda essa surpresa funciona ou exclui
o participante. Obviamente, nós o tornamos assíncrono. Vamos em frente e buscamos
nosso cliente de mesa. E vamos aguardar
o cliente de
mesa Dot Delete um coletor. E o que eu não fiz
para isso foi fornecer os parâmetros que precisamos
fornecer para excluir o async. Portanto, para excluir de forma assíncrona, precisamos passar o que seria a chave de partição e
os valores da chave da linha. E esses são os valores que
passamos para nossa operação de exclusão. Agora, se você tiver dúvidas sobre o que deve transmitir, você sempre pode considerar
os senhores
dos métodos e isso
ajudará a lhe dar uma dica. Então vá em frente e passe os parâmetros e isso deve
ser a entidade de exclusão de um coletor. Peço desculpas por não excluir async, mas excluir a entidade async. O Async poderia ter
excluído a tabela. Tudo bem, então a entidade de exclusão
usará esses dois parâmetros. Agora, criamos nosso serviço de
armazenamento de tabelas. Fizemos um pequeno ajuste
em nossa entidade aqui. E é claro que precisamos
atualizar nosso contrato, que é a interface, porque eu mudei a
assinatura desse método. Então, vou pular até
lá e alterar o Delete para usar os dois parâmetros
conforme o esperado. E para atrair participantes, também
precisamos
atualizá-lo com isso. Tudo bem? Então, uma vez que o contrato está satisfeito
, o serviço é feliz. E não temos
conflitos nem registros. E então, como sempre, temos que registrar isso. Então, vou pular
para o nosso program.cs e ver
um ponto do construtor. Deixe-me tentar isso de novo. Serviços Builder dots. Os pontos adicionam um serviço com escopo para o
serviço armazenado de TI implementado pelo
Table Storage Service. E é isso. Então,
quando voltarmos, vamos criar o controlador
e as visualizações correspondentes que nos
permitem facilitar
o processo de registro.
11. Criar controladores e visualizações: Agora vamos criar nosso controlador. Vamos diretamente
para o controlador de seleção de
pasta de controladores controlador de seleção de
pasta e faremos apenas
um controlador MVC com ações de leitura e gravação. Clique em Adicionar e vamos
chamá-lo de conquista. Esse controlador
de registro
de participantes, é claro, precisa ser anexado. E aí está a participante, sua dissertação sobre controladora. Vamos injetar nosso serviço de TI. Então, eu Table Storage, I Table Storage Service. Certo? E podemos
prosseguir e inicializar isso como um campo privado
somente para leitura. Tudo bem? E agora podemos começar
com nossas ações. Agora, de um modo geral,
você gostaria de usar modelos de
visualização para lidar com o que
está acontecendo na frente e de forma
diferente do back-end. Mas, mais uma vez, esta
é uma demonstração rápida,
então, perdoe a falta de melhores práticas e
abstrações estamos
apenas fazendo uma demonstração simples
para mostrar a conectividade. Depois, você pode usar
todas
as melhores práticas
e separações de preocupações para nossa visualização de índice A
primeira coisa que
queremos fazer, claro, é obter os dados. Então, eu quero dizer que
os dados var são iguais ao ponto de armazenamento da tabela
sublinhada para obter participantes. Agora, isso é um síncrono
que eu preciso esperar. E então, é claro,
converta esse método em um
método assíncrono também. Então eu posso passar esses
dados para a visualização. Agora vamos gerar a visualização. Então clique com o botão direito na palavra
Exibir, clique em Adicionar visualização. E eu só vou
para Razor View. E vou usar
um modelo de lista. E a classe modal será
uma entidade participante. E eu posso deixar todo o resto. Não preciso referenciar
bibliotecas de scripts e clicar em Adicionar. E em pouco tempo nossa
visualização do índice foi gerada. Então, a partir daqui, não vou me
preocupar em modificar o que estamos
vendo ainda. O que vou modificar é esta
seção em que
passamos as chaves primárias para que
possamos usar a chave de linha da função. E é claro que precisamos
de uma festa robusta, então deixe-me nomeá-los
adequadamente. Portanto, precisamos do id e
da chave de partição, que serão
chamados de indústrias. Posso dizer que indústria
é igual à vírgula
da indústria ponto do item e id
é igual a rho KI. Tudo bem, então é isso que
teremos que
passar para nossa edição, nossos detalhes e
nossos métodos de exclusão. Por quê? Como tudo isso precisa da
chave de partição e do valor do id, porque precisamos
buscar para editar, precisamos buscar
para ver os detalhes. E, claro, a exclusão, também
precisamos desses dados. Então é assim que
vamos fazer o índice. Agora vamos passar
para o próximo, que são os detalhes. E os detalhes
seguiriam uma operação semelhante. Mas lembre-se de que aqui estamos
pegando o id int e valor da
indústria de strings. E, na verdade, id é uma string porque
vamos usar uma grade. E precisamos fazer
alguns ajustes aqui. Portanto, isso precisa
ser uma tarefa assíncrona. Claro, eu poderia
ter usado o IntelliSense
para converter isso. Então, deixe-me tornar o método Async para estimular essa digitação. E então não estamos
recebendo participantes, mas estamos recebendo nosso dez d, o que não
espera que superemos o do setor
e o valor da identificação. Então, passamos esses dados para cima e retornamos a
visualização com os dados. E então podemos gerar
esses dados, essa visão. E vamos detalhar, então usaremos o modelo de detalhes com a mesma entidade
e adicionaremos isso. No momento, criamos nossa visualização de
detalhes. Então, deixe-me fechar tudo o que
não precisamos neste momento. Para Create, podemos
deixar isso porque
não precisamos de nenhum dado prévio
, nem de Louis. Então, vamos dar uma olhada nisso. Se quisermos que eles forneçam
o valor do setor, teoricamente
poderíamos fornecer a eles uma lista suspensa que
teoricamente não se baseia em suas necessidades. Você pode fornecer a eles
uma lista suspensa para que eles possam escolher entre uma lista selecionada de setores que você gostaria ter como chaves de partição. Para esta demonstração simples, vamos digitá-la. Mas é claro que, no
futuro, talvez
você queira ter uma lista
selecionada que você reconheça como seu partido deve ou potenciais particionar os
valores-chave, certo? Então, vamos deixar de lado a visualização
Create. Bem, vamos gerar essa visão. Então, vou clicar com o botão direito do mouse em
Adicionar visualização, visualização razor. E então usaremos nossos
modelos de criação contra a mesma
entidade. Vá em frente e adicione. Depois que os criadores
foram adicionados, percebe-se que
não está dizendo assíncrono, não
precisávamos de nada
assíncrono na criação, mas precisaremos fazer algumas coisas assíncronas
dentro do método de postagem. Portanto, no método de postagem, espera-se que
voltemos ao participante. Objeto da entidade. Lá vamos nós. Então o que
vamos fazer é tentar. Portanto, antes mesmo de entrarmos na tentativa, antes mesmo de
chamarmos o serviço, precisamos inserir alguns dados. Então, aqui eu queria dizer
que a chave de partição, a chave partição da
entidade
participante, será igual a e, em seguida, essa é
a entidade participante. Pontos. Em que concordamos? Acho que foi a indústria. Isso está correto. E então eu vou dizer que
a chave de linha, então adicionamos a chave de linha. Pronto, vai
ser igual aos pontos de Boyd, novo GUID. Para amarrar. Esses dois, podemos ligar
para o
nosso Serviço de Armazenamento de Tabelas
para incomodar o participante e dar a ele o objeto de entidade
participante. Porque todos os outros
campos teriam sido definidos por meio do preenchimento
desse formulário de criação. Eu tenho um erro aqui porque a conversão em
assíncrono não foi concluída. Então, vamos nos encontrar. Essa é uma tarefa e
esse erro desaparece. Então, agora podemos
passar para as edições. Portanto, a edição terá que fazer uma busca semelhante aos detalhes. Então, podemos seguir
em frente e fazer isso. E, claro, os parâmetros
precisam ser semelhantes. Então, por que você digita quando
pode copiar e colar? E depois, oh, precisamos que
isso seja assíncrono, então vamos converter isso. E então, na pós-operação, vamos realmente
fazer algo semelhante ao que
fizemos na criação. Portanto, precisamos ter certeza de que
redefinimos uma
chave de partição e uma chave de linha. E então seguimos em frente e somos absurdos. Tudo bem, então você
verá que as criações e edições basicamente seguem o
mesmo tipo de procedimento, mas precisamos ter um pouco
mais de cuidado com o OER. Então, vou mudar todo esse parâmetro e
ele será processado e garantirá que tudo
funcione da maneira que esperamos. Então, mais uma vez, estamos
definindo o setor. O que é a indústria deve ser
a chave de partição. Mas eu quero ter uma
nova chave de linha? Eu não gostaria de
ter uma nova chave de linha. Então, vou remover essa porque a
chave de linha já vem com essa entidade e
sempre podemos ocultá-la
no formulário, certo? Então, eu quero configurar
a tecla de linha novamente, vou redefinir
a chave de partição para o
caso de esse valor mudar
quando foi editado. Agora, eu preciso descobrir que isso, claro, é síncrono. Lá vamos nós. Podemos seguir em frente. Agora, para a exclusão, vou renunciar à
necessidade do registro de exclusão. Vou excluir a
confirmação pelo menos por enquanto. Então, vou
remover o getMethod e depois implementaremos
o método post. Eu já o converti em um método assíncrono e coloquei o ID
da string e os parâmetros
industriais da mesma
forma que fizemos para a edição. E o que faremos é esperar excluir o participante depois que ele receber os valores do setor
e do ID. Então, o que faremos no índice é refatorar isso de um link para um botão real de envio de
formulário. Basta colocar o fórum aqui. E o que temos é
uma tag de formulário simples com a ação ASB como delete, então ela atingirá o método post. E então temos duas
entradas, ambas ocultas. E o valor aqui será vinculado. E deixe-me fazer essa correção. Portanto, uma deve ser a chave de rolagem de
pontos
do item e a outra é a
indústria de pontos do item, isso é valor. E então, os nomes, é
claro, correspondem aos nomes dos parâmetros que
descrevemos em nossos parâmetros de axônio. E então temos uma entrada
que é um botão de envio, que parece
um botão de perigo. Então, posso comentar neste link
porque não precisamos dele. Então é assim que vamos
lidar com a exclusão. Agora eu tenho mais uma coisa
que quero destacar, é um pouco do nosso refator e é uma espécie
de crítica que eu tenho Visual Studio e à forma como ele refratora métodos quando
os usa como coletor. Mas anexando essa
palavra-chave assíncrona ao final, eu não gosto da bolsa. Além disso. exemplo, você
notou que todos esses são métodos
assíncronos e eu não
disse para tornar o participante assíncrono. Então, se você quiser manter essa convenção
de nomenclatura com
seus métodos, tudo bem. Não é algo
que eu necessariamente pratique além da minha preferência
pessoal. Percebi que o MVC
não faz um bom trabalho ao lidar com navegação quando o async é adicionado ao nome
do axônio e da visualização. Portanto, fique do lado seguro. Minha sugestão é que,
se ele foi renomeado para assíncrono, basta remover esse nome assíncrono. Essa é uma. Então faça isso para todas as ações. Você verá que eu
já passei. E todos aqueles que eram editados assíncronos e indexados assíncronos
e tudo mais. Ele foi renomeado
apenas para o nome original,
sem adição de async. Isso é para renomear
as visualizações, certo? Portanto, todas essas visualizações
realmente tentarão ir para
a versão assíncrona ou
serão chamadas de assíncronas. Portanto, você pode simplesmente
remover essa palavra-chave assíncrona. Estou apenas clicando nele
e pressionando F2 no meu teclado para renomear. E a ação dentro
daquelas que são formas que
ela deveria ir
para Editar, certo? Portanto, esta é apenas uma
rápida refatação que estou sugerindo apenas para garantir que não tenhamos problemas. Na verdade, nunca me
sentei e disse: Deixe-me tentar fazer a convenção de
nomenclatura assíncrona funcionar. Eu simplesmente prefiro sem, então é algo que
tentei evitar. Certo. E
esse já foi gerado antes. Se você quisesse ter
a página de confirmação, poderíamos ter mantido a visualização
gerada de acordo. Então, esse é o
formulário real que acabei de usar
no índice para ter certeza de que
podemos simplesmente
excluir a postagem. A atividade final
é acessar
nosso layout e
mudar nosso menu para ter a opção de acessar
o controlador de
registro de participantes, que será direcionado para a visualização
do índice
e, em seguida, você poderá dar um nome a ele. Então, acabei de remover o link
de privacidade e substituí-lo pelo link de inscrição do
participante. Então, quando voltarmos,
podemos ir em frente e testar.
12. CRUD de armazenamento de tabela de teste: Tudo bem, então estou executando o aplicativo e
caso você esteja se perguntando
como executá-lo. Mais uma vez, certifique-se de que o novo projeto seja
seu projeto de startup. E então você pode
simplesmente executar sem depurar se
quiser depurá-lo. E por todos os meios, vá em frente. Então, estou correndo sem
depurar e
vou prosseguir e clicar no registro de
participantes. Então, vemos que nossa página de índice
foi carregada, não obtivemos erros. Isso significa que está conectado
ao nosso armazenamento ou cones. A mesa viu que nada
voltou e está nos mostrando em branco. Isso é bom. Vamos criar novos. Se eu criar um novo
registro de teste, digamos que teste, teste e
teste em ti.com
e na Industries IT
e, claro, não fornecerei
uma chave de partição, chave de linha carimbos de data
e hora para que as
peças sobressalentes da limpeza precisem
ser executadas em nossa interface de usuário. Mas tudo bem. Vamos clicar em Criar. E aqui vemos que ele
voltou com o disco. Então, a indústria e
eu estamos particionando chaves os mesmos valores e
obtivemos uma nova chave válida para ou 0 e um valor de
timestamp. Se eu entrar em detalhes, veremos tudo sobre isso. Portanto, sabemos que a
chave de partição fetch one by ID está funcionando. Se eu for para Editar, vamos tentar mudar
alguma coisa aqui. Então, este é o teste 123, e eu vou salvar, e isso editou esse arquivo. Tudo bem. Agora vamos tomar
nota ou algo assim. Se eu for para o Edit novamente, mudei o setor desta
vez para a ITU um-dois-três ou vamos tentar algo
real: educação, certo? Então não era, era educação. E então eu tentei salvar os nós para obter um recorde
totalmente novo. É a mesma chave de regra, mas com uma chave de partição diferente. Então você precisa
ter muito cuidado com isso. Porque especificamos que o armazenamento da tabela está
usando uma chave composta. Ele está examinando a chave de
partição e a chave de linha. Além disso, Deshawn poderia ter vários registros com
o mesmo, desculpe, podemos ter várias
partições com os registros com o
mesmo valor de chave rural. E é isso que
estamos vendo aqui. Essa é uma
partição diferente e estamos obtendo o valor da
chave da linha aqui, certo? Então, foi em frente e
criou um novo recorde. Então, isso é algo com o qual você
precisa ter muito cuidado ao gerenciar o valor
da chave de partição. E por esse motivo, você provavelmente poderia usar
a tecla de linha como ambas as partes, tecla
Sean Andrew, para garantir que seja o mesmo
registro o tempo todo. Agora, vou excluir,
e não estou me preocupando em
consertar a estética e nada mais. Na verdade, isso é só para
fazer uma demonstração com
a integração com a nuvem, não necessariamente para atender
aos estilosos, certo? Então,
vou testar
a exclusão e remoção de
um desses registros. E lá vamos nós. A exclusão funcionou. Então, aí mesmo, acabamos de
validar que nossa equipe de armazenamento de tabelas funciona. Saiba que o que você pode fazer para uma análise mais aprofundada
agora é limpar
coisas como criar e editar formulários, para que você não precise exibir a chave de linha e a chave de
partição com
carimbo de data e hora. Podemos removê-los
do Create e podemos removê-los
do nosso carimbo de data/hora. Então, vamos
limpar isso. Então, para nossa lista de índices, provavelmente também não precisamos
ver essas coisas. Então, eu não preciso ver
a chave de partição, linha, chave, provavelmente
linha Keegan, stay. Mas, como é
mais uma ideia, eu provavelmente gostaria de
movê-la para a frente. E mesmo assim, você realmente
quer ver essa grade? Agora? Vamos remover isso também. Portanto, nenhum desses três
itens também existe aqui. Então, nós apenas o mantemos
bem e limpo. E aí mesmo, acabamos implementar crédito
para o Table Storage. Agora vamos ver se nossos
requisitos mudaram. E não, precisamos adicionar alguma forma de upload de arquivo a esse formulário
porque os participantes precisam fazer o upload de um avatar ou
alguma imagem que precisaríamos armazenar com segurança e depois
recuperar para exibição. Então, agora vamos ver
como podemos aproveitar Blob storage.com ou
algo parecido.
13. Adicionar serviço de upload de Blob: Tudo bem, então nossos
requisitos mudaram. Sei que precisamos armazenar uma imagem
enviada para o usuário, mas não queremos armazená-la em nossos servidores por vários motivos. Então, o que vamos
fazer é transferir essa responsabilidade para
um Armazenamento de Blobs do Azure. Então, vou
adicionar um novo campo a essa entidade de tabela e chamá-la de nomes de imagem. Então, o que vamos
fazer é renomeá-lo para ter o mesmo valor que
a chave de linha teria. E ele apenas armazenará
o nome da imagem aqui. E então isso servirá
como um ponto de referência daqui para frente, sempre que
precisarmos referenciar a bolha. Agora vamos criar um novo serviço, e eu já fiz isso. Vamos chamá-lo de Serviço de Armazenamento de
Blob. Então, basta clicar com o botão direito do mouse em serviços, adicionar uma nova classe e chamaremos
um Serviço de Armazenamento de Blobs. E no meu Serviço de Armazenamento de Blobs, eu meio que escrevi notas, alguns dos códigos já são de
alguém para
orientá-lo , para que você não
precise me ver digitar. Agora, o que fiz foi primeiro criar um construtor onde
injetei a configuração. Então você pode ir em frente e fazer isso. Também tenho um campo
chamado nome do contêiner, que chamo de imagens do
participante. Agora, a razão pela qual estou
usando todas as letras minúsculas é isso e eu mencionei as convenções
de nomenclatura anteriormente. Com o Blob of storage, você não pode usar
caracteres maiúsculos no joelho. Então, qualquer coisa que você esteja nomeando, você tem que nomeá-la em letras minúsculas, você pode usar alguns caracteres
especiais. Nota de rodapé, estou apenas mantendo
todas as imagens dos
participantes em letras minúsculas. E então eu tenho meu metil e isso
vai criar um
contêiner de clientes. Agora você
ainda pode
embrulhá-lo nesse caminhão para detectar qualquer exceção, especialmente relação à nomenclatura, porque o que estamos fazendo aqui é tentar
criar um contêiner, o cliente de contêiner
Blob, para
ser específico, e passar string de conexão da configuração e
o nome do contêiner. Agora, se o seu nome
não corresponder
, você definitivamente
terá uma exceção. Então você pode fazer isso, tente
capturar e colocar um ponto de interrupção aqui para ver
qual é a exceção Você provavelmente obteria um
erro 400 nesse momento. Não, vamos
seguir em frente e ver não existe
um peso criativo. Então, quando tentasse fazer
isso, seria a exceção. E então, se chegar até aqui, queremos devolver o contêiner. Então esse é o nosso primeiro método
em nosso novo serviço. Agora, a próxima coisa que
queremos fazer é carregar um blob. Então, vamos ter um
método chamado upload blob. Será uma
tarefa assíncrona que retorna uma string e usa o arquivo do iPhone
como tipo de parâmetro. Então, quando fazemos o upload usando
MVC ou dotnet Core, em geral, o arquivo de formulário é o tipo de dados
que recebe o arquivo carregado. E então vamos
passar o nome de uma imagem. A primeira coisa que estou fazendo é estabelecer qual será o nome
Blob. E o nome da imagem aqui
representa qualquer nome que eu queira armazenar em um
arquivo como motivo. É uma boa ideia renomear seu arquivo antes de fazer
o upload . Se você tiver vários
usuários tentando fazer upload de
arquivos com os mesmos nomes, você
acabará em colisão. Portanto, é melhor renomeá-lo para algo
exclusivo do registro. Então, podemos seguir em frente e
estabelecer os nomes das bolhas. Então, estou pegando o valor do nome da
imagem, posso
passar um valor exclusivo. E então eu estou anexando
esse nome
ao caminho original do
arquivo que foi carregado. Portanto, o caminho que obtém o
ponto do arquivo do Formulário de
Extensão O nome do arquivo
examinará todo o nome do arquivo, obterá o ponto, JPEG, PNG , seja
o que for, e o
anexará ao nosso nome exclusivo. Chegamos ao nosso país
e ao nosso cliente. Em seguida, vou estabelecer
um objeto de fluxo de memória onde copiarei do arquivo de formulário para
o fluxo de memória,
redefinirei arquivo de formulário para
o fluxo de memória, a posição para zero
e, em seguida, usaremos
o cliente, carregarei o blob com o nome Blob
do fluxo de memória. Tudo bem? E esse padrão representa o token
de cancelamento. Você poderia
realmente viver sem ele. Então, como não estamos usando tokens de cancelamento, você
os remove. E então eu vou
devolver o nome Blob. Agora, o cliente em si é,
na
verdade, um cliente, aqui vai ser um tipo de bolha de resposta, informação de conteúdo. Então, a partir desse objeto, você pode realmente observar
o valor e ver diferentes informações
sobre uma bolha que
acabou de ser carregada. Se você precisar de
mais informações do que apenas o nome do Blob, sinta-se à vontade para usá-las. Também poderíamos usar o cliente de
contêiner para obter mais informações
posteriormente. Mas, por enquanto, eu só queria
armazenar o nome do arquivo. Agora que fizemos o
upload do arquivo, vamos ver como
recuperaríamos um blob. Agora, recuperar o
blob será uma situação especial porque o que acontece é que quando configuramos o contêiner
Blob, ele passa
a ser privado por padrão. E já
estabelecemos que usamos URLs para acessar os diferentes
blobs após o upload Analisaremos mais
os URLs posteriormente. Mas o fato é que,
se for privado, você não pode simplesmente acessá-lo. E você não quer simplesmente
torná-lo público porque talvez nunca queira encontrar alguém que possa acessá-lo. Portanto, ao recuperar nossos blobs, precisamos gerar o que
chamamos de tokens SAS, que são
tokens de assinatura de
acesso compartilhado , e veremos isso neste método. Portanto, nosso novo método
aqui é obter o URL do blob, que
retornará uma string. Portanto, é uma tarefa assíncrona
que retorna uma string. E, mais uma vez,
leva o nome da imagem. Então, inicializamos um cliente de
contêiner e
também inicializamos
um cliente Blob em relação ao
nome da imagem. Agora temos o que
chamamos de construtor de bolhas. E esse é o construtor
usado para gerar o
token de assinatura de acesso compartilhado ao qual acabei de mencionar. Então, o que vamos
fazer aqui é blob SAS builder é
igual a um novo objeto, que receberá
o nome do contêiner que queremos acessar, o nome do Blob que
desejaremos acessar. Em seguida, vamos definir a
expiração desse kit de ferramentas, o que significa que após
esse tempo passar, estou configurando
isso para 2 minutos. Tudo bem? Mas depois desse tempo, ninguém mais poderá
acessar ou usar esse link para
acessar o recurso. Eu estava sentado
no protocolo para ser HTTPS e o recurso para ser B. Se você passar o mouse sobre o recurso, verá que B
é específico para blob. Se for de um
tipo diferente, você pode ver referido C para contêiner e você tem opções
diferentes. Mas, por enquanto, estamos apenas
fazendo Blob Storage. Então, estamos definindo B como
o tipo de recurso. E então eu vou
definir a permissão para que o blob SAS builder seja lido. Portanto, nesta enumeração, talvez seja necessário incluir uma referência de
uso ausente para essa enumeração. Mas temos várias
opções aqui. Você pode gerar um token SAS
que permita excluir, para anúncios, etc.,
todas as permissões. No momento, só queremos ler
porque queremos poder ver a imagem
ao recuperá-la. E então vamos retornar blob dot
para gerar um token SAS com opções
do construtor,
não para string. Então, isso vai disparar, gerar esse token SAS também nos
fornecer o URL completo. E então ele retornará todo
o URL para nós. Saiba que, quando
seguirmos em frente, queremos remover essa bolha sempre que o
registro for excluído. Então, vamos
ter mais um método aqui que removerá
o blob. Então, a tarefa pública AsyncTask removeu o blob e estamos pegando
o nome da imagem mais uma vez, conectando ao contêiner, criando um cliente de blob. E então eu vou
dizer, vou esperar, excluir
blob dot,
se existir, um coletor. Isso é apenas uma sensação de segurança. Há exclusão assíncrona, mas exclui se existir. Hills com se houver,
se não existir, então não há erro, então
podemos excluir todos os instantâneos. Portanto, lembre-se de que, com o armazenamento
Blob, temos controle de versão e, cada vez que
houver uma colisão, ela pode criar uma nova versão
e manter esse histórico. Podemos optar por excluir tudo depois de
remover a bolha. Então, isso é tudo para o coordenador do nosso Serviço de Armazenamento de
Blobs. Vou seguir em frente
e extrair essa interface. E com essa
interface extraída,
passamos para o nosso
program.cs e registramos esse serviço
da mesma forma que
fizemos com o serviço
de armazenamento de tabelas. Não, podemos refatorar nossos
controladores e visualizações. Vamos começar com nossos
controladores ou controladores. Vou injetar o Eye Blob Storage Service
e inicializá-lo. Nós já sabemos como fazer isso. E então, para a ação de indexação, vou adicionar
isso para cada loop, alguém para dizer para
cada item em detalhes. Porque lembre-se de que isso é
retornar a lista de participantes. Eu vou dizer para
obter o nome da imagem. Então, eu tento fazer com que
o nome da imagem seja igual ao
serviço de armazenamento de blob que obtém URL do blob, nome da imagem
do ponto do item. Por que estamos substituindo esse valor? Bem, eu não vou
armazenar o URL inteiro, estou apenas armazenando
o nome, certo? Então, esse é um
nome exclusivo, extensão de ponto. Então, estou passando esse nome, que a bolha terá. Em seguida, vou obter todo
o URL do SAS, qual vou substituí-lo
para retornar à
exibição para exibição. É claro que, em um
ambiente mais limpo, teríamos criado essa abstração e os modelos de visualização de
Cingapura para que
pudéssemos massagear
melhor os dados e assim por diante. Mas, abandonando todas
essas melhores práticas, esse é um exemplo claro
de como podemos simplesmente obter a
URL para esses pulsos de papel. Em seguida, temos os detalhes. Então, para obter detalhes, está fazendo
algo semelhante. Nós temos o registro aqui. E então eu vou
ver que o nome da imagem de um ponto de registro é igual a obter o sangue. Mais uma vez, você não tem um método de criação de postagem em
formato. Eu adicionei um novo
parâmetro, que é o parâmetro do arquivo I-Form. Portanto, esse arquivo I-Form
capturará o upload
do arquivo a partir do formulário que
modificaremos e alguns. Eu também refatorei
o código disso. Então, comecei definindo
um ID para uma nova grade. Então eu estou colocando a chave de
linha para ser esse ID. Agora, meu nome exclusivo para nomear meus arquivos
blob será o ID. Não precisa ser a identificação. O ID sempre será
único. Acho que essa é uma maneira fácil de
simplesmente examinar o Blob Storage e identificar o que é o que acontece
sempre que eu precisar. Então, estou vendo se o tamanho do ponto do arquivo de
formulário , o que
significa que algo
foi carregado, certo ,
é maior que zero, então
vou definir o nome
da imagem igual ao que
ela retornará. Então, lembre-se de que
nosso blob de upload, se eu for para a implementação colocando
isso e
o nome da imagem, esse será o ID. Vamos
ajustar isso, fazer o upload. E então eu estou apenas
retornando o resultado da concatenação do
id e da extensão. Então é isso que
vamos acabar como nome da imagem. E então, se nada
foi carregado, podemos configurar como
uma imagem padrão. Tudo bem, e então vamos em frente
e absurmos o participante. Vamos passar para
nossa edição e edição. Estamos apenas fazendo o mesmo
se verificarmos,
onde, se o arquivo do formulário
for maior que zero, prosseguiremos e
enviaremos nosso blob. Estou passando o valor da chave da
linha e o arquivo de formulário que também
adicionamos como parâmetro. Agora, uma coisa na visualização que acho que não indiquei,
se eu acessar a Visualização aqui, garante que
lembremos que
removemos os valores de entrada da chave de linha, chave partição e
carimbo de data e hora. Mas, para manter a chave de
linha original para o registro, certifique-se de
ter esse
ASP oculto para a chave de linha no formulário. Tudo bem, então isso é Edit. E então, finalmente,
vamos para a exclusão. Excluir é meio complicado
agora porque precisamos do nome da imagem original
para remover a bolha. Então, o que eu tive que fazer foi
Fitch, o primeiro participante. Então, podemos excluir
isso e, em seguida ,
remover a bolha
ignorando esses dados, o nome da imagem, porque nós a buscamos primeiro,
nós a temos na memória. Podemos removê-lo do armazenamento
da tabela e, em seguida,
usar o que armazenamos na memória e, em
seguida, empacotar com
esses dados para a exclusão. Finalmente, vamos analisar as diferentes mudanças
que fizemos nas visões. Então, para a visualização de criação, adicionei uma nova seção que nos
permitirá
fazer o upload do avatar. Então, acabei de criar
um novo grupo de formulários. Temos o rótulo aqui e
acabei de digitar o upload do nosso tar. E então o tipo de entrada é arquivo, e o nome aqui é
arquivo formado de forma que
corresponda ao parâmetro que estamos
procurando na postagem. E isso é tudo para o nosso Create. E minhas
habilidades de copiar e colar saíram do controle. Então, deixe-me remover esse material
de validação. E eu preciso desse mesmo
controle dentro da edição. Então, também vou adicionar
esse grupo de formulários
ao formulário de edição. Então, se nada for carregado, tudo bem, porque mantemos a mesma bolha e
tudo está bem. No entanto, se algo
for carregado, faremos o upload e ele fará a substituição
adequada. Agora, na visualização de detalhes, adicionei outra
combinação de DT DD a essa lista de dados. Então aqui eu tenho Avatar e
agora eu tenho essa etiqueta de imagem, que vai
assumir que ela é
proveniente do nome da imagem do ponto do modelo. E eu estou apenas sentado com
nossa largura de 150 e uma altura de 150. Em seguida, no índice, adicionei outro cabeçalho de tabela. E se você quiser rotulá-lo, você pode dizer avatar ou exibir
imagem, seja ela qual for. E então, no TR para os dados, adicionei um novo td, que é uma tag de imagem semelhante. A fonte
será o nome da imagem do ponto do item, a largura
será 50 e a altura 50. Tudo bem? Também refatoramos
a forma dos bits para colocar os links HTML dentro
do fórum para que eles sejam
exibidos da esquerda para a direita em vez da
exibição aleatória que tínhamos anteriormente. Sei que disse que
não precisávamos consertá-lo, mas me desculpe, não pude
continuar consertando. Então, coloquei esses
dois links dentro
do formulário ao lado
do botão Excluir envio. E eu adicionei os novos
atributos HTML para a classe, aviso
BTN para edição e
btn-primary para detalhes. Então, com todas
essas mudanças feitas, vou
salvar tudo. E quando
voltarmos, faremos nossos testes.
14. Recursos de serviço de blob de teste: Um ajuste rápido antes de
começarmos os testes. Lembre-se de que sempre que
quisermos facilitar upload de formulários ou arquivos em um formulário, precisamos incluir esse
atributo no formulário. Então, esqueci de
ressaltar que,
na lição anterior,
estamos reformando nossas vistas. Portanto, o tipo de tinta é igual aos dados do formulário de barra com
várias partes. Portanto, certifique-se de que isso esteja
presente no formulário de criação, bem
como em nosso Formulário de Edição. Também vou adicionar
esse campo oculto ao Formulário de Edição para garantir que possamos reter
o valor do nome da imagem. Portanto, lembre-se de que precisamos
manter o nome da imagem original. E se o usuário fizer o
upload de uma nova imagem
, mudaremos a antiga. Mas precisamos manter os nomes das imagens originais para
que, quando fizermos uma atualização, esse valor não seja perdido. Agora vamos passar para nossa edição. Após a ação e
acabei de fazer ajustes,
são necessários aqui. Primeiro, quero
aumentar
essa declaração if porque o que
fizemos foi absurdá-la antes mesmo de
tentarmos verificar se
deveríamos atualizar o arquivo. E também devemos
atualizar o campo da imagem. Você mencionou o campo de nome, certo? Então, negligenciamos essa
parte por completo, mas podemos corrigi-la agora. Portanto, devemos verificar se o tamanho do arquivo do formulário
é maior que zero. E todas as coisas desse
arquivo de formulário também podem ser nulas. Então, vou fazer com que
esse tipo de não seja seguro. Coloque esse ponto de interrogação lá. Portanto, se o arquivo do formulário tiver um valor, verificamos se o comprimento
é maior que zero. E, claro,
também poderíamos verificar se
não é igual a nulo, porque obviamente
teria um comprimento, mas qualquer verificação com a qual você
se sinta mais confortável,
então vamos em frente e dizemos:
faça com então vamos em frente e dizemos que o nome da imagem seja igual
ao que foi enviado. Se fizermos o upload de algo, presumiremos que somos novos, precisamos atualizar
o nome da imagem. E então podemos seguir
em frente e ficar chateados. Agora vamos
testar nosso site de dados, limpar todos os registros existentes
porque eu estava testando tudo e não criei outro registro para
realizar esse teste. Então, se você quiser
limpar todos os
seus registros de armazenamento de tabelas existentes, você sempre pode voltar ao seu navegador de armazenamento ou usar o Explorador de Armazenamento que
você pode ter baixado. Vá até as tabelas e você
verá a tabela que
criamos anteriormente e, em seguida, você poderá excluir qualquer registro
que achar necessário excluir. Agora, quando eu executo, execute este aplicativo e navegue até o
registro e veremos nossa tabela. Deixe-me criar um novo registro e eu vou fazer o
upload de um avatar. E eu vou escolher uma imagem aqui e dar a ela primeiro nome, sobrenome, endereço de e-mail
e indústria e criar. E lá vamos nós. Agora estou vendo uma imagem
exibida aqui no Avatar. Olha isso. E estou vendo todos
os dados que foram usados para saber o que é essa imagem. Se eu clicar em Detalhes, recebo um link quebrado. Então, claramente, precisamos
fazer algum trabalho aqui. E o que eu vou
fazer é inspecionar o elemento. E lá vamos nós. Esse é o erro. Ei, na verdade é imprimir
as palavras, modelar essa imagem. Então, vamos pular e corrigir isso onde isso
realmente deveria estar no sinal. E isso não deve
ser um modelo pequeno, deve ser um grande modelo M
para representar os dados. Então, deixe-me
corrigir isso e executá-lo novamente. E quando eu recarrego
esse registro aqui, a imagem
está sendo
exibida corretamente? Não, eu ainda tenho meu
Inspect Element aberto. E se você olhar para esse URL, verá que esse é
o URL do blob real. Então, vamos analisar o que
toda essa questão de URL é um parafuso. Se eu voltar para
o portal e atualizar, veremos nosso registro
e/ou registro com nome de imagem. Essa é a mesma extensão de ponto
de
valor, é claro, da
chave de linha. Isso é bom. Mais uma vez, renomeamos
para que possamos ter exclusividade
em cada upload. Agora, se eu pular para
os contêineres de blob, a primeira coisa é
que você verá que as imagens dos
participantes
foram criadas e criadas como um
blob ou contêiner privado, certo? Se eu entrar, assistir às imagens, cada bolha de bloco
que estiver dentro
desse contêiner também
será privada. Então, eu posso ir aqui e
copiar o URL. Se eu tentar acessar esse URL, receberei a mensagem de que o recurso especificado
não existe. Agora sabemos que isso
não é verdade porque aqui está URL para o armazenamento Blob e depois o contêiner
e, em seguida,
o nome do arquivo e nós apenas o
copiamos para sabermos que
o arquivo existe. Então, como está definido como
privado no nível de acesso, não
podemos
acessá-lo diretamente por meio do URL. Mais uma vez, com base
no nível de acesso, podemos ativar ou restringir o acesso
por atacado a todos os blobs
em nosso contêiner. Agora, este é privado. É por isso que geramos
esse URL do SAS. E então, quando
clico em gerar SAS, você vê que agora
podemos configurar todos esses parâmetros e, em seguida, gerar o token e o URL do SAS. E então, uma vez que o Tolkien
e o URL tenham sido gerados, se eu copiar isso e tentar acessá-lo
no navegador novamente. Bem, meu navegador está realmente
baixando o arquivo. Tudo bem, então isso é o que
acontecerá se eu estiver usando, se você estiver usando um
determinado navegador, em outros navegadores, ele
realmente abrirá o arquivo. Mas vamos dar uma olhada no URL para colá-lo
um pouco
no Notepad Plus,
Plus, para que possamos
inspecioná-lo um pouco mais. Não, começamos
mais uma vez com as mesmas partes, o armazenamento dos cones, o contêiner e
depois o nome do arquivo. E então você notará que
tem uma sequência de caracteres de consulta. Então, temos Sb, essa
é a permissão, é para o nosso
Windows. Começa. Ok. Essa é a hora. Quando isso acaba? Essa é a hora. O que
é o protocolo? Https, e então
temos outros parâmetros. O tipo é blob e a assinatura é aquela string degenerada
aleatória. E o SV lá representa
uma versão assinada, certo? Você não definiria
isso, isso será definido enquanto a assinatura
estiver sendo gerada. É isso que esse token
SAS traz para a tabela em que obtemos
esse URL especial que permite o acesso por tanto tempo
quanto estivermos entre o horário de
início e término. E você vê aqui, isso
foi definido para um dia. Isso estava apenas usando
as opções padrão. Mas é claro que podemos
definir um período de tempo específico para o propósito para o qual
precisamos desse token. Agora que você tem
uma ideia do que está acontecendo nos bastidores quando estamos recebendo esse URL. Vamos pular para Editar. E quando editamos com
fetch the record, deixe-me tentar alterar esse arquivo. E depois de clicar em Salvar, encontrei um erro. Então, é claro que eu quero te
mostrar o IRS e depois vamos
resolvê-los juntos. Portanto, o erro aqui que
foi detectado após
a tentativa de fazer o upload do blob foi que o blob especificado
já existe. Tudo bem? Então, é claro que não podemos fazer o upload um blob que já
tenha esse nome. Então, o que eu vou fazer é remover a bolha, se
ela já existir, e então podemos
prosseguir e criar. Então, para o blob de upload, vamos pular para blob de
upload e vamos
modificar o que está acontecendo
dentro desse método. Então, do jeito que está, vamos
até o contêiner e
tentamos fazer o upload. E se você passar o mouse sobre isso, verá onde diz que cria um novo blob de bloco, o que significa que obviamente
retornará uma exceção, como você viu, em que
o blob já existe. É por isso que ler a
documentação é muito importante. Para sobrescrever um blob de bloco
existente, obtenha um cliente de blob
e, em seguida, faça o upload. Tudo bem, vamos seguir
as instruções para que
possamos reutilizar esta linha em que
obtivemos aquele cliente de blob e substituir essa linha de
upload original uma nova que diz um upload de ponto de
blob úmido assíncrono. E então eu estou transmitindo,
estou usando parâmetros nomeados, então saiba exatamente o que
estamos passando para onde o conteúdo
será o fluxo de memória. E então vamos
sobrescrever verdadeiro. Portanto, ao definir override como true, ele substituirá
quaisquer blobs existentes. E sem definir
isso, seria falso. Então, acaba recebendo a mesma
exceção que obtivemos se deixarmos de inserir
esse parâmetro de substituição. Agora, há outra
reviravolta nisso. E é isso se eu
fizesse o upload de um J peg inicialmente e depois
o alterasse para um PNG. Nesse ponto,
mesmo que o valor do id, o nome da imagem seja o mesmo, vamos acabar
com dois arquivos diferentes. E nós realmente precisamos
armazenar arquivos antigos, certo? Então, tecnicamente
falando, você
também pode executar uma exclusão antes carregar, apenas para garantir
que você não acabe com duas versões diferentes do que deveria ser o avatar de uma
pessoa. Portanto, você também pode considerar
isso. Então, para descobrir o que aconteceu
na ação de edição, vou enviar
o nome da imagem original como um parâmetro para nosso método de
upload de blob, o que significa que agora teremos que
introduzir um novo parâmetro. Portanto, nosso novo parâmetro
será string, que não é o nome audível do Blob
original. E eu estou inicializando para não. E, claro, se
atualizarmos a interface
, também precisaremos atualizar
a implementação. E temos o mesmo
parâmetro listado aqui. Agora que temos esse valor
original do nome Blob, vou verificar se ele existe. Então, eu vou dizer que,
se a string dot não for nula ou vazia e
passar esse valor, então queremos aguardar, remover o blob e dar a ele
o nome original de Blob. Vamos remover
o blob existente e, em seguida, podemos
prosseguir e fazer o upload. Então, você vê que há
muitas dinâmicas a serem diferenciadas em nosso caso,
porque podemos acabar com arquivos
e extensões diferentes não
podemos garantir
que isso sempre substitua
o existente. É mais seguro remover o antigo e depois
adicionar o novo. Já em uma
situação em que talvez o nome do arquivo sempre seja consistente de qualquer maneira
, você provavelmente não
precisa passar por tudo isso. Mas, mais uma vez, opções. Agora que fizemos
esses ajustes
, vamos testar
nossas edições. De novo. Carreguei o formulário, já escolhi meu outro
arquivo e depois vou ver. E lá vamos nós. Agora eu
tenho um novo Avatar. Eu
alterei com sucesso o upload ou a imagem do Blob
associada a esse registro. Então, isso é bom e fácil. Claro, tinha algumas nuances. Conheça o
exemplo que dei que a extensão do arquivo
pode ser diferente e acabaremos com
vários arquivos para o mesmo registro que eu realmente
tive e que aconteceu comigo. Então aqui está uma versão com JPEG e outra
versão com PNG, a origem dos arquivos PNG, o novo arquivo era JP
e, em vez de substituí-lo, apenas criei um novo que
preciso desreferenciar. É por isso que você pode querer remover antes de fazer o upload para garantir que você não acabe com
vários arquivos em potencial. Até mesmo este foi carregado
sem uma extensão anteriormente. Essas são pequenas coisas com as quais
você deve ter
cuidado, cuidado e atenção
ao manusear bolhas. Finalmente, vou
testar essa exclusão. Então, vamos excluir esse registro e saberemos que o armazenamento da tabela
exigiu que ele fosse excluído. Vamos voltar aqui e pelo
menos um desses
arquivos deve desaparecer. Ok, dois deles foram porque eu removi
o original. Em seguida, também removi o que estava
anexado ao registro. Este não foi anexado a nada , então eu posso excluí-lo
manualmente. Isso é bom. Mas pelo menos
agora sabemos que estamos escrevendo
com sucesso em nosso armazenamento de blob, lendo nosso armazenamento de blob
usando um ensaio, um talo. E isso nos dá
acesso limitado apenas por um período. E podemos remover
e carregar uma nova, alterar associações de arquivos
e tudo mais. Agora, quando
voltarmos,
implementaremos nosso serviço de filas. E os cenários em que um participante deseja que
um participante seja registrado. Queremos enviar um e-mail, mas não queremos nos conectar diretamente ao serviço de e-mail. Em vez disso, queremos
adicioná-lo a uma fila para que possa ser consumido posteriormente
, sem ser processado.
15. Adicionar serviço de fila: Então, agora vamos implementar
nossos mecanismos de fila. Então, a primeira coisa que vou
fazer é criar um novo modelo. Estou modelando um conjunto de dados porque não é algo que
vamos armazenar. Mas eu quero uma aula
para que possamos ter uma
mensagem fortemente digitada de acordo. Então, vou ligar para
essa mensagem de e-mail. E a mensagem de e-mail
terá três propriedades. Então, o primeiro será uma string, que é o endereço de e-mail. Então, teremos carimbos de data e hora. Então, vou apenas dizer data, hora chamada de data e hora. E a última coisa é
a mensagem real. Então, isso é bom por enquanto. E então, como sempre, teremos que
contratar um novo serviço. Então, vamos adicionar outro cluster ou pasta
de serviços. Desta vez, vamos
chamá-lo de serviço. E nosso serviço de fila terá um construtor
que injetará ou nossa configuração
semelhante a outros serviços Também
teremos um nome de fila definido, que chamo de e-mails dos
participantes. Agora vou
ter apenas um público que é uma tarefa pública
chamada enviar mensagem. E enviar uma mensagem vai
pegar o objeto da mensagem de e-mail. Então, mensagem de e-mail, e eu vou chamá-la
apenas de mensagem de e-mail. E o fato é que
estou programando para essa fila. Mas você também pode querer manter esse tipo de sinal flexível em
relação a outras dicas com as quais talvez
precise interagir. Então, o que você pode fazer
para esse serviço de fila é, em vez de definir
o nome da fila, você poderia simplesmente dizer nome da
string como um parâmetro aqui. Para que você possa realmente definir o nome da fila ao
passar a
mensagem desejada. Mas então esse é um problema específico. Então, vou apenas
tornar tudo
específico para nossa operação de
mensagens de e-mail. Agora vou inicializar um cliente de fila e
não vou me preocupar criar um método inteiro para isso desta vez, porque
só temos uma mensagem,
um método que
é enviado a mensagem. Então, eu fui dizer que var
acute client é igual a um novo cliente de fila em que
precisamos da string de conexão. Nós obtemos isso
da configuração. Obtemos o nome da fila
com base nesse valor. E então definimos as opções do cliente de fila para
que codificem a mensagem 64. Então lembre-se de que adiamos,
ligamos e desligamos isso. Quando estamos criando
a própria fila. Então, como de costume,
veremos um cliente Q ou um cliente da fila de espera criar, se não existir, um coletor. Então, vamos em frente e nos
certificamos de que ela exista antes de
tentarmos enviar uma mensagem. Para enviar uma mensagem,
podemos simplesmente dizer que Q Client não envia mensagem. E, claro,
existe uma opção assíncrona, mas deixe-me mas deixe-me
inserir qual deve ser a
mensagem. Portanto, observe que eles esperam
uma string de texto de mensagem, mas temos um objeto
de mensagem de e-mail. Então, deixe-me ir em frente
e eu vou esperar primeiro. Agora, como faço para converter isso em algo que pode
ser enviado como uma string? Bem, podemos
serializá-lo para ser JSON. Então, posso dizer que var message
é igual a JSON, converta esse objeto serializado. E então passamos
nossa mensagem de e-mail que apenas converterá nossa classe em uma mensagem JSON ou objeto de string
JSON. E então podemos passar essa
sequência como nossa mensagem. Podemos extrair nossa interface. Esse é o único método que precisamos
para
extrair a interface, registrá-la
no program.cs, como de costume, e estamos
adicionando-a como escultura, assim como os outros
serviços anteriores. E então podemos modificar ou os cumes comparecerão ao controle de registro. E depois de injetarmos
nosso novo serviço de QI, serviço QI, eu gosto desse nome. Agora podemos modificar os pontos de acesso. Obviamente, criar
seria um ponto onde, depois que tudo
estiver pronto e salvarmos, queremos criar
nossa mensagem de e-mail. Portanto, posso dizer que var email é
igual a nova mensagem de e-mail. E vou definir o endereço de
e-mail para ser o endereço e-mail
do ponto da entidade participante que foi inserido. Certo. Podemos definir a data e hora como uma data e hora (UTC) conhecida
e, em seguida, podemos definir nossa
mensagem para algo como olá, primeiro nome,
sobrenome, olá. E eles estavam apenas
concatenando. Então, estamos usando,
bem, a interpolação. Então, estamos usando a
interpolação aqui. E então eu coloquei a
linha com a barra
invertida n, barra invertida r. Obrigado por
se inscrever neste evento. E eu tenho uma sequência. E então eu trouxe a linha
novamente e então eu disse, seu registro foi salvo
para referência futura. Agora que tenho
esse objeto de e-mail, posso chamar meu serviço de
fila e C, enviar mensagem e simplesmente
entregá-la a esses objetos de e-mail. Obviamente, sabemos que podemos fazer coisas
semelhantes em outros lugares nosso aplicativo porque,
se ele for editado, poderemos informá-los de
que não foi modificado. Então olá, Nome, Sobrenome, seu registro foi modificado com sucesso e então
enviamos essa mensagem. E então, se for excluído, também
posso fazer isso
porque, lembre-se, teríamos pré-carregado
esses dados aqui. Então, depois que tudo
foi removido, criamos nossa mensagem de e-mail e
eu copiei e colei. Então, obviamente,
usaríamos dados como objeto aqui para
endereço de e-mail, nome, sobrenome. Em seguida, a mensagem de e-mail
é modificada para dizer que foi removida com sucesso
e, em seguida, enviamos. Então, isso é tudo o que
integraríamos nosso serviço de filas
em nossas operações. Agora, quando
voltarmos, vamos validar tudo isso.
16. Serviço de fila de teste: Então, vamos
testar alguém para criar um novo registro e
fazer upload de uma imagem. E, claro, estamos
apenas usando testes, testes, testes e IoT criados pela indústria. E depois de validarmos isso, tivermos um registro e
nosso blob carregado, podemos ir para o
nosso Explorador de Armazenamento. E vou atualizar
tudo para ver
se aquela nova fila ou
raquete de tênis dá sinais e dizer Refresh. E agora eu vejo os e-mails dos participantes como minha fila e entro lá. E eu tenho várias mensagens
porque eu estava testando, certo? Você pode ver aqui que
temos várias mensagens e eu fiz uma operação completa para garantir que
cada uma funcionasse. Então, eu tenho um aqui
que mostra que, quando foi criado, seu registro não foi salvo para referência futura. Isso é bom. E então
temos outro aqui que diz que foi
removido com sucesso. Temos outro aqui
que diz que estava tudo bem, eu não fiz nenhuma modificação, mas você vê aqui que todas essas mensagens estão
realmente na fila. Então, vamos imaginar agora que o serviço de e-mail
na verdade não era, certo? Portanto, esses deveriam
ter
sido e-mails enviados imediatamente. Mas nosso serviço de e-mail estava maduro. Isso significa que o usuário
teria se registrado
e talvez tivéssemos saído da operação com a impressão de que ele é ou
uma distribuição em campo. Como o serviço de e-mail
foi concluído, o campo do site conectado e, em seguida, lançar uma exceção e provavelmente lhe
deu uma mensagem de erro. Não queremos que isso
aconteça, certo? Outro cenário é que tudo bem, talvez tenhamos
um tratamento adequado de erros. Então, apesar de
tentarmos conectar o doador de
serviços de e-mail , não
criamos uma exceção, mas esse e-mail foi
perdido para sempre, certo? Portanto, o QI é uma excelente
maneira de guardar nossas mensagens para nossas operações até que possamos realmente
processá-las mais tarde. Quando voltarmos, agora que sabemos que nosso q está funcionando como esperamos, vamos criar
um pequeno utilitário que realmente
selecionará as
mensagens da fila. E uma vez que recebemos as
mensagens da fila, qualquer operação que você
precise realizar pode
ser realizada.
17. Logs e chamadas de serviços: Agora, enquanto testamos nosso aplicativo, eu só queria dedicar
alguns segundos para
mostrar o que está
acontecendo no console, você tenha uma
ideia do que está acontecendo por trás de todas
essas chamadas de serviço. Por isso, conectamos
nosso serviço de mesa ou Serviço de Armazenamento de
Blobs e
nosso Serviço de Armazenamento em Filas. E se você
observar o console ou os registros enviados
pelo aplicativo para cada solicitação, verá que
estamos apenas enviando GET e post e
diferentes tipos de solicitações
HTTP ou HTTPS
para vários URLs. Na verdade,
não é muito mais
complicado do que isso. Então, essencialmente, nossos clientes de serviço e
todos eles são, na verdade apenas invólucros para clientes HTTP
que estão se comunicando por meio de APIs RESTful com
cada um de nossos serviços. E dissemos no
início do curso que as APIs RESTful nos permitem interagir e gerenciar
nossos recursos. Aqui está um exemplo vivo
de trabalhos de resistência. Então, quando conversamos com
nosso serviço de tabela, quando o rp está carregado, tentamos obter os dados. Tudo bem, e mais tarde você
verá que interagimos com, ok, aqui está uma para a qual
obtemos uma ferramenta. Certo. Aqui está o
que eu queria onde excluí o registro. Então, ele foi excluído do Blob. Então, se você olhar o
URL, verá
que esse é o serviço blob, certo? E excluiu o nome Blob. E isso é uma solicitação de exclusão. Tudo bem, aqui está a
saída em que algo foi atualizado no Q. Tudo bem, então essa é a
URL do serviço de fila. E aqui está uma solicitação de postagem em que ela criou
algo em Q. E aqui estou
tirando fotos das tabelas. Então, estou apenas apontando
que tudo é, na verdade apenas uma chamada de API RESTful
acontecendo em segundo plano.
18. Leitor de mensagens de fila de configuração: Agora que sabemos que
nosso serviço está funcionando, vamos criar um serviço
que assinará
esse serviço de fila e
consumirá a mensagem. E então, o que quer que você precise fazer com isso,
você pode depois. Mas vamos criar um
utilitário que
conecte e consuma
essas mensagens. O que significa que eu vou
criar um aplicativo de console. Então, eu vou,
na solução, abrir um novo projeto ou
adicionar um novo. E este
será um aplicativo de console simples. Portanto, escolha um modelo de
aplicativo de console. E vamos
chamar isso de uma demonstração de
pontos de consumo de um console . E então vamos
em frente e clicaremos em Avançar. Usaremos o.net
seven mais recentes disponíveis no momento
da gravação
e do Create. Agora preciso adicionar um pacote e o
mesmo pacote que adicionamos anteriormente para armazenamento em filas,
que são filas de
armazenamento de zero pontos. Então, vou fazer isso rapidamente
e acho que agora
todos nós sabemos um todo para adicionar
ou empacotar rapidamente. Então, vou escolher essa rota em que
vou criar um novo grupo de itens
e depois colar a mesma referência de pacote
que estava no aplicativo MVC. E guarde isso. E você vai
ficar em segundo plano e resolver
essa dependência para mim. Agora vamos escrever um código. A primeira coisa que
gostaríamos de fazer, é claro, é configurar ou estabelecer a conexão com
nosso armazenamento de filas, certo? E isso é feito por meio da cadeia de
conexão da nossa conta de
armazenamento. Saiba, você tem algumas opções
ao fazer isso, a opção mais fácil seria criar uma variável aqui. Sou chamado de
string de conexão e atribuo o valor a ela. Mas então, pela razão
óbvia de que você não quer colocar sua string de
conexão diretamente no código e na
camada codificada , não vamos
adotar essa abordagem. Para essa situação,
podemos usar um segredo, o que significa que
teríamos que instalar alguns pacotes adicionais e armazená-los em
um arquivo de configuração e, em seguida,
referenciá-lo adequadamente. E então, por extensão, também
podemos simplesmente definir uma
variável de ambiente global em nossa máquina. E então, é claro, se
vamos implantar esse aplicativo em
qualquer outra máquina, eles terão que garantir que a variável de
ambiente também
exista . Alguém pode adotar essa abordagem para esse exercício
específico. Então, para fazer isso, vamos
usar nossa janela de terminal. E se você estiver usando, se estiver em uma máquina Windows, usaremos o
seguinte comando. E então eu vou
te mostrar o correspondente para Linux e macOS. Se você estiver em uma máquina Windows, esteja usando código do Visual
Studio ou do Visual Studio, você pode dizer set X, nome próprio, que estou vendo como sua string de
conexão de armazenamento. E então colocamos
o valor aqui. Então, vou passar para o
projeto web
em que tínhamos o valor da cadeia de conexão
dos exercícios anteriores. E vou usar isso
aqui como valor e conjunto. Certifique-se de obter a
formatação correta. Você pode ver que eu cometi alguns
erros porque
copiei uma vírgula e adicionei aspas
extras. Portanto, certifique-se de obter
apenas as aspas e o valor intermediário. Agora, se você estiver usando
Linux ou Mac OS, o comando é
basicamente idêntico. Mas em vez de dizer conjunto X, você verá exportações. E é o mesmo formato
para exportar o nome da variável e
depois o valor. Uma desvantagem desse método
é que talvez seja necessário reiniciar o computador posteriormente
para poder clicar em Pausar, reiniciar e, quando voltar, continuaremos de onde paramos. Agora que
definimos essa variável de ambiente, podemos definir a variável da
cadeia de conexão aqui. Então, vou dizer que a string conexão de string é
igual a environment, get environment variable, e
descobrimos isso pelo nome. Tudo bem, então vamos
inicializar uma nova fila de clientes. E isso será semelhante
ao que fizemos antes. Cute client Q é
igual a nu q client, referenciando a
cadeia de conexão e o nome desse Q. Vou tentar receber
mensagens da fila. Então, a primeira coisa que
quero
fazer é garantir que o QA exista, o
que é simplesmente
rudimentar, certo? Se eu esperar, existe um ponto Q. E então, dentro
dessa declaração if, vou prosseguir e verificar se há muitas mensagens lá. Então, primeiro
pegue a propriedade. Então eu digo que as propriedades Q
são iguais ao nosso peso q dot get
properties a sink. E então, uma vez que eu tenha
essas propriedades, agora posso verificar se
quais são os cones de mensagem aproximados, desculpe. Eu vou dizer que as propriedades
que se aproximam da mensagem d de
Cohen são maiores que zero. Tudo bem, então isso é
apenas um número que indica quantas
mensagens estão na fila. E então eu estou configurando um loop de
tempo para dizer, bem, enquanto há
mensagens na fila, então queremos fazer alguma coisa. Então, eu vou ver, vá em frente
e busque as mensagens. Então, vou dizer que a mensagem de
string é
igual a e vou aguardar o método que estou
prestes a criar, recuperar. próxima mensagem é sumir, ou não precisamos necessariamente
seguir essa convenção de
nomenclatura assíncrona. Mas eu quero recuperar, deixe-me acertar a ortografia. E então eu vou
dizer ponto de console, escrever linha e
imprimir essa mensagem. E estou apenas
divulgando a mensagem recebida. Vamos implementar esse método. Então, vou
degenerar o método abaixo. Será um
método assíncrono que retornará uma string. E dentro desse método, primeiro
vou
recuperar uma mensagem. Não, você pode recuperar
até várias mensagens ao
mesmo tempo, certo? Então, eu queria dizer mensagem de
fila, mensagem recuperada,
e isso é uma matriz. E então fui esperar que o Q dot recebesse mensagens de forma assíncrona. E então podemos pegar um cone. Esse cone é o
número máximo de mensagens e o mínimo é um
e o máximo é 32. Então, eu posso realmente dizer, me
dê até 32
mensagens uma de uma vez. Mas, por enquanto,
vou fazer apenas um. Então, vamos
processá-los um por um. E então eu vou
ter que converter de base 64 em uma matriz de bytes
e, em seguida, de uma
matriz de bytes em uma string. Eu vou explicar
tudo isso para você. Em nosso Explorador de Armazenamento. Quando
olhamos nossas mensagens, vemos que as mensagens ficam em texto
simples e isso parece bom. No entanto, ao
clicar duas vezes nele, você verá que ele
mostra que o decodificou como base 64. Então, está me mostrando
o que está na mensagem. Mas, na verdade, se você
olhasse para ela em repouso, se alguém quiser
ter acesso
à fila
e tentar ver se as mensagens estão tentando interceptar as mensagens em vez de ver apenas uma
string codificada em base 64 que, na verdade,
não veria os textos
como você está vendo. Não. Então, por esse motivo, quando estamos processando
essas mensagens, elas estão realmente aparecendo
como mensagens codificadas em base 64. E então eu tenho que converter
da base 64, certo? Portanto, esta é a string então
codificada em base 64. Então, na verdade, são dados
binários, certo? E então eu posso converter novamente
para UTF a partir desse beta RE. Então, isso é tudo,
todo esse fluxo tem que funcionar. Se estivermos usando a codificação base-64, depois de recuperar
a mensagem da fila, gostaria de removê-la. Então, eu vou dizer que um peso
q dot exclui a mensagem de forma assíncrona. E vamos remover o
uso da mensagem recuperada do que o ID da mensagem e o recibo pop da
mensagem recuperada. Tudo bem, e se você
passar o mouse sobre essas propriedades, verá o que cada
uma delas significa. Então, basicamente, depois de
processarmos a mensagem ou
recuperarmos
a mensagem e podermos removê-la da fila. E então eu vou
retornar a mensagem, que podemos então processar.
Eu não me lembro disso. Sim, vamos
consolar aquela terra dos ratos, mas isso poderia
ser facilmente enviar o e-mail ou armazenar no banco de dados. Porque se for uma operação
assíncrona e for algo que
precisa acontecer depois. Como dissemos antes, especialmente em uma situação de
microsserviços, esses podem ter sido os agentes que removem a
âncora de qualquer processo que a
distorção esteja conduzindo, certo? Portanto, este é apenas um aplicativo de console
simples. Em um cenário real, você provavelmente usaria nosso trabalho
ou serviço que está sempre ativo, que precisaria ser executado
manualmente todas as vezes. O código teria
a
mesma aparência com nosso
trabalho ou serviço. Se fosse sua função, que veremos
mais adiante no curso. Em seguida, veremos como também podemos lidar com esse tipo de
situação. Então, vamos
testar e vou
definir alguns pontos de interrupção
em algumas áreas-chave. Isso é apenas para que
possamos rastrear exatamente o que está acontecendo quando o
cordão passa. Então, vou me certificar de
que o console operacional é meu projeto padrão e
prosseguir com a depuração. E atingimos os primeiros
pontos de interrupção para que
possamos ter certeza de que
o Q existe. E então eu vou
pular para o loop inteiro. Então, foi em frente e
buscou as propriedades. Vamos dar uma olhada nesse objeto
e vemos aqui que o cone aproximado da
mensagem é cinco. Então, por causa disso,
entramos em nosso ciclo completo. E então vamos prosseguir e
recuperar a próxima mensagem. E eu vou pressionar F5
para que ele pule para baixo. Vamos avaliar. Primeiro, recebemos uma mensagem, não, porque são mensagens, embora especifiquemos uma, ela ainda retornará
um tipo de matriz ou coleção. Então, na verdade, ele retornará uma matriz com esse
número de mensagens. Então, obtemos uma matriz neste caso com uma mensagem, tudo bem. Agora, quando olharmos para esse objeto de mensagem
recuperado, veremos que temos nosso corpo. Temos um cone de defila, o que significa quantas vezes essa mensagem
ficou vermelha? Temos uma data de expiração com base
nas diferentes
configurações que teríamos configurado e
temos textos de mensagens,
portanto, temos todas
essas propriedades
nesse objeto de mensagem, objeto de mensagem de
fila. Agora, observe que o corpo
é uma string codificada. Então é disso que
estamos falando. Isso não faz sentido
para qualquer ser humano, a menos que você esteja andando no computador. Então, vamos converter
isso em uma string e depois
convertê-lo em uma matriz de bytes. E então vamos
converter
da matriz de bytes em
uma string real. Em seguida,
excluiremos a mensagem, porque agora que
recuperamos a mensagem, não precisamos mais
dela na fila. Então, essa é a mensagem
que é o corpo do
JSON sobre o qual falamos ou
que vimos na prévia. Então, agora podemos
prosseguir com a exclusão. E então a mensagem
é retornada. E vou pressionar
Continuar e remover os pontos de interrupção para que todas as mensagens
sejam impressas no console. E aqui eu tenho uma exceção.
19. Limpeza de código e otimização: Tudo bem, bem-vindos de volta, pessoal. Nesta lição, vamos
apenas fazer algumas otimizações
e limpezas de código. E a primeira atividade de otimização e
limpeza de barras nos leva volta ao
aplicativo de console que acabamos de fazer. Então, o que eu fiz foi substituir o
loop while por um for-loop. Como estou recebendo um
número definido de mensagens, faz sentido ler um
número diferente de vezes, certo? Então, isso
definitivamente nos ajudará a superar esse
erro de índice
fora dos limites , pois só chegaremos
até aqui quando estivermos
dentro dos cones. Então esse é o nosso refator rápido. Claro, existem
várias maneiras de fazer isso e isso foi apenas um lapso de julgamento sobre o motivo pelo qual acabei fazendo o
loop while em primeiro lugar. Ei, nós vivemos, aprendemos. Então essa é nossa primeira correção. Não, quero voltar
minha atenção para o projeto web e para o fato de que, ok, temos o armazenamento
ou a sequência de dois pontos aqui. Mas então, em nossos serviços,
como armazenamento de blob, armazenamento em
filas e armazenamento de
tabelas, estamos instanciando um
cliente todas as vezes. Então, provavelmente podemos refatorar
isso um pouco. Então, vamos começar
comprando um novo pacote. E vou usar
o console do desenvolvedor aqui para o console do desenvolvedor aqui que
possamos
estar todos na mesma página,
esteja você usando o Visual
Studio ou o Visual Studio Code. E no projeto web, vou usar dotnet add package. E o pacote são extensões de
pontos da Microsoft que são suas. Agora, isso
nos dará
a capacidade de acessar nosso program.cs. E enquanto ele está sendo instalado, eu começo a escrever o código. Então, isso me dá a
capacidade de acessar o program.cs e ver um
construtor de pontos serviços
e adicionar como seus serviços
ou, em vez disso, seus clientes. Então eu posso inicializar
isso com um construtor e o corpo lambda e
finalizá-lo com um ponto e vírgula. Então, o que estamos fazendo
dentro disso? Adicione zero glândulas. Bem, agora posso dizer construtor. Pontos, adicione clientes. Então você vê aqui, não, eu posso adicionar um cliente de serviço blob, eu posso adicionar planos de serviço de fila e eu posso adicionar um cliente de
serviço de tabela, tudo isso aqui. Então, vamos começar com o cliente de serviço
add blob, e temos várias sobrecargas. A sobrecarga mais fácil
de usar é aquela que requer uma cadeia de
conexão. Então, posso pular para a
configuração e acabamos de obter essa string de conexão de armazenamento. E vamos para a configuração do
Builder Dot. Eu não entendi bem a ortografia. Pontos de configuração. Bem, não é isso. Crie nossa configuração. E então a chave que
estamos procurando é nossa cadeia de
conexão de armazenamento. Então, agora que tenho
esse lugar, posso reutilizá-lo em outro lugar. Então, o construtor adiciona blob, cliente
de serviço, e estou passando esse valor da string de
conexão. Tudo bem, eu também posso construir a filha dela teve que atender
clientes e adivinha? Ele pega a
cadeia de conexão e adivinha? Eu também posso acrescentar. Se
você disse tabela, então você está absolutamente correto. Agora vamos nos concentrar um pouco no cliente do serviço de
fila. Se formos até
o serviço de filas, lembre-se de que, quando
criamos um novo cliente, tínhamos algumas opções. E essa seção de opções incluiu a
codificação padrão que queremos. Então, de volta ao program.cs, podemos realmente estender essa
configuração adicionando opções de configuração de
pontos
ao final dessa linha. E então vamos
criar um pequeno corpo
de configuração. Estou apenas usando C como
meu token lambda. Então, dentro dessa seção de
configuração, estou definindo que a
codificação de mensagem de ponto C é igual à mesma codificação de base 64. Saiba que
tudo isso foi feito. Podemos injetar em nossos serviços existentes usando esses serviços em vez de
provisioná-los em tempo real. Então, o que podemos fazer é começar
com o cliente Blob Storage. E o que
vamos fazer é usar o serviço injetado para
obter um cliente de contêiner. E não precisamos chamar
esse método toda vez. Então, vou injetar o cliente
do serviço blob nesse construtor e
inicializar um campo local. Nós já sabemos como fazer isso. E com isso injetado,
posso, na verdade, em vez de dizer que var container
é igual ao nosso peso, obter o cliente do contêiner Blob. Na verdade, posso substituir isso por um cliente de contêiner dot
get do cliente de serviço blob. E isso não é uma pia. É por isso que estamos
recebendo essa linha vermelha. Tudo bem? E eu posso analisar e
substituir todas as instâncias
desse método manual
apenas usando nosso cliente. E então, se eu quiser, posso apagar esse método. O que vou deixar
lá para a posteridade , para que possamos ver
o que costumava ser. Temos os clientes
de serviços de mesa que injetamos e inicializamos. E então podemos substituir
nossa forma de obter um cliente de mesa. Eu posso saber, basta ligar
para o cliente de serviço, obter ponto, obter cliente de mesa. E então referenciamos o nome da tabela e apenas a caixa que está vazando. Lá vamos nós. Então, agora todas essas referências, e isso provavelmente é
mais semelhante à inicialização
do Blob Storage
Client. E ainda é o armazenamento da
fila ou a inicialização do cliente.
Então, tudo bem. E, claro, esse método
está aqui para referência. Eu analisei e
substituí todos eles, mas só queria
ressaltar que o que não estamos fazendo aqui é criar,
se não existir. Portanto, existe a possibilidade de
que, ao obter o cliente, ele retorne nulo
porque não existe. Então, outro fator operacional poderia ter sido simplesmente eliminar isso e ainda devolver o cliente do serviço
com base nessa chamada. Tudo bem, então ainda
poderíamos reter a chamada do método para isso e retornar o cliente para
cada chamada, certo? Ou para cada método. Então
, depende de você, certo? Também poderíamos ter definido um cliente de tabela no topo aqui, ou um campo no topo. Em seguida, inicializamos o campo
dentro do nosso construtor e usamos apenas os campos. Portanto, existem várias
maneiras de fazer isso. Agora, nessa nota,
vou
voltar para o program.cs e veremos outra maneira abordar isso. O que estamos fazendo
aqui é injetar o cliente, o cliente do serviço. E então, como estamos injetando o plano de serviço,
precisamos criar uma nova instância
do cliente real que nos
conectará ao recurso. E se quiséssemos apenas
registrar o cliente
direto no recurso? Portanto, teríamos que adotar uma abordagem um pouco diferente com o que estamos
fazendo aqui. E vou fazer
isso em outro anúncio seção
de seus clientes. Só para que possamos
fazer um acordo inicial. Tudo bem? Então, digamos que eu queria o
cliente de fila diretamente, não o plano de serviço de fila, não o nome do serviço,
mas o cliente real. Na verdade, eu usaria o cliente
builder dot add. Então, isso me permite
especificar os tipos de dados. Então, eu quero as opções de fila, cliente e Q. E então eu vou
inicializar um delegado usando espaços reservados para os
parâmetros esperados para esse método Se você passar o mouse sobre a planta do AD, verá o que
os parâmetros representam. E então vamos usar uma expressão lambda
para nosso corpo de objeto. E então, dentro
desse método,
esperava-se que retornasse uma nova
instância do cliente Q. Isso significa que se eu pulasse para esse serviço de filas,
onde
estaríamos inicializando
nossos clientes. Na verdade, eu poderia usar
esse código aqui e retornar um novo cliente
que está usando a configuração ou a string
de conexão de armazenamento. Eu também poderia colocar o nome da fila
na minha configuração. Portanto, não preciso ter isso
codificado no arquivo. Então, vamos fazer isso. Na verdade, vou criar
uma seção totalmente nova
na configuração e
chamá-la de seu armazenamento. E eu vou colocar a cadeia de
conexão lá. E vou simplesmente
concluir que o armazenamento de palavras
é meio redundante. Agora a chave e
eu estamos fazendo o mesmo, ao mesmo tempo, porque
não quero esquecer. Então, agora a chave para a configuração
da conexão seria a cadeia de
caracteres conexão de dois pontos
do Armazenamento do Azure, certo? Porque agora está
nessa subseção. E eu estou fazendo tudo isso, não. Então, coloque uma vírgula lá. Agora posso colocar o
nome da fila ou vários nomes de filas,
quaisquer que sejam os nomes de Q e que
precisarem para meu aplicativo. Eu posso colocá-los aqui. Então o nome da fila
vai ser, não me diga, lá
vamos nós. Eu também faço isso. Lá vamos nós. Portanto, o nome da fila será a hora dos e-mails dos
participantes e eu usarei
apenas o Blob Storage. Acabei de definir as chaves do armazenamento
nulo e de tabela. Porque essa técnica
pode ser usada para todos os três serviços de armazenamento. Então, de volta ao program.cs, vou fazer um
ajuste rápido porque
vou precisar dos valores
de configuração aqui. Então, vou mudar isso
de Builder para apenas dizer B. E então o nome
da fila será alterado na configuração de
pontos do construtor. E então podemos
referenciá-la como sua seção de armazenamento e
a chave do nome da fila. Tudo bem? E é claro
que precisamos voltar. Portanto, isso precisa ser devolvido clientes
de
UQ com todos esses valores. Agora que temos esses clientes Q registrados no serviço de fila, posso saber como injetar esse cliente
Q diretamente. Não preciso dessa
referência direta ao nome da fila. E eu posso usar esse cliente
fofo para fazer todas as comunicações
adequadamente. Então, eu não preciso fazer
isso na inicialização dentro da mensagem de envio ou dentro desse serviço? Não, eu posso fazer algo semelhante
para o Table Storage. Posso simplesmente pegar o nome dessa
tabela e
colocá-lo dentro do json das configurações do nosso
aplicativo. E então, em nosso program.cs, vou copiar e colar o cliente da fila
na mesma seção. E vamos
adicionar um cliente para clientes de
tabela com opções de cliente de
tabela. E o que estamos fazendo aqui é retornar uma nova instância
do cliente de tabela com uma string de conexão de armazenamento e nosso nome,
chave ou
armazenamento de tabela de armazenamento do Azure . Tabela, nome da tabela de armazenamento, o que quer que você
chame de armazenamento de tabelas. Tudo bem? Então, agora eu posso injetar
esse cliente de tabela diretamente no serviço de armazenamento de
tabelas. Então, em vez de injetar
o cliente do serviço, bem, vamos fazer as duas coisas. Então, o cliente de tabela e eu
vamos inicializar isso. Então, estou deixando todo esse código aqui para que você tenha uma
referência futura, certo? Não é necessariamente
que você precise
de tudo isso e acho que já
sabemos disso. Mas não preciso inicializar um cliente de tabela toda
vez que posso simplesmente usar meu serviço injetado, muito parecido com o que precisávamos
fazer com os clientes Q. Então, agora eu posso simplesmente fazer um cliente
de tabela diretamente
por meio dessa base de código. Então, essas são apenas algumas
otimizações que você pode fazer em seu código
para garantir que, oh, bem, eu não
precise mudar essa. Então esse método
agora seria arquivado, por assim dizer, certo? Portanto, essas são algumas atividades de
otimização e limpeza que
você pode remover algumas dessas
referências codificadas à configuração. E então, é claro, discutimos o fato de que você
provavelmente não deseja armazenar todas essas chaves
dentro das configurações do aplicativo. Então você pode realmente
usar segredos. E para usar segredos, basta
clicar com
o botão direito do mouse no arquivo de imagem CSP e descer para
gerenciar os segredos dos usuários. E então você pode adicionar
essa seção lá. Portanto, não é uma pessoa que deve ser verificada no
controle de origem e não é imediatamente
visível para olhares indiscretos, mas ainda pode
ser acessada ou configurada em nossa startup. Não há nenhuma razão pela qual eu
não estou configurando um cliente blob enquanto estou fechando. Não vou configurar
nosso cliente Blob. Porque lembre-se de que
o cliente Blob é criado diretamente contra
o Blob com base no joelho. Portanto, embora seja um
pouco mais eficiente,
basta seguir em frente e injetar
as faixas de serviço. Ainda precisamos
criar um cliente em tempo real com base no blob que
está prestes a ser processado. Porque, mais uma vez,
não sabemos qual bolha será processada
para começar com ela. Assim, você pode validar se são incentivos e esses
novos registros funcionam. E eu só vou
comentar sobre um deles. E isso é tudo para essa atividade. Vamos encerrar esse módulo.
20. Conclusão: Então, usamos outra máscara,
uma, e concluímos este
módulo como seu armazenamento. Durante a duração deste módulo, analisamos como criar e
gerenciar uma conta de armazenamento. Isso envolveu nossa
interação com Serviços de
Armazenamento de Tabelas e Filas de
Blob, todos parte dessa
oferta de contas de armazenamento do Microsoft Azure. Analisamos como podemos
usar o portal do Azure ou o navegador de armazenamento que
podemos baixar seu computador para interagir
com os diferentes serviços. Mais uma vez, Blob
Table, Queue storage. Então, vimos que poderíamos
gerenciar o conteúdo deles, seja no portal do Azure ou localmente usando o navegador
de armazenamento. Também analisamos
como podemos desenvolver uma solução dotnet Core para
usar a conta de armazenamento. Então, aqui,
analisamos armazenar e recuperar a
cadeia de conexão para o armazenamento ou cones durante todo o fim de semana e escrever código para interagir com os
diferentes serviços e a nuance está intermediária. E, em última análise,
todos podemos afirmar que cada
um desses serviços está sendo gerenciado por meio de chamadas e codificação da API
RESTful. Tudo o que estamos fazendo é provisionar clientes
HTTP para interagir com
os serviços subjacentes. Também finalizamos
analisando como
poderíamos facilitar a
comunicação assíncrona usando filas. E isso nos fez
implementar
uma espécie de padrão Pub Sub, onde publicamos uma
mensagem na fila. E então tivemos
outro aplicativo
inscrito na fila que retirava a mensagem, a
processava e seguia em frente. Então, esse é um exemplo
do padrão pop-up e de como
podemos implementar a
comunicação assíncrona. Agradeço por se juntar a
mim neste módulo. Te vejo na próxima aula.