Conteúdo
COMO COMPRAR Internet Computer (ICP) E RECEBER UM BÔNUS DE €30 (APENAS 3 PASSOS)
Compre Internet Computer (ICP) por Binance
PASSO 1: REGISTRO
IMPORTANTE: PARA OBTER €30 EM BTC AO SE INSCREVER NO BINANCE, FAÇA-O A PARTIR DESTE LINK. CONFIRMANDO SEU E-MAIL, VOCÊ RECEBERÁ A RECOMPENSA.
ETAPA 2: DEPÓSITO DE FUNDOS
ETAPA 3: ADQUIRA CRIPTOMOEDA
Por que comprar Internet Computer (ICP)
O que é Internet Computer (ICP) ?
O Internet Computer estende a funcionalidade da Internet pública de uma rede que conecta bilhões de pessoas (via protocolos TCP / IP) para uma plataforma de computação pública que capacita milhões de desenvolvedores e empreendedores (via protocolo ICP).), Oferecendo uma nova forma revolucionária construir. Serviços de Internet de mercado de massa abertos, plataformas de todo o setor, sites e sistemas corporativos seguros e DeFi, tudo sem a necessidade de computação legada, como serviços de nuvem centralizados, bancos de dados e firewalls.
O computador da Internet é criado usando um protocolo descentralizado matematicamente seguro (PKI), combinando a capacidade computacional de milhares de data centers independentes ao redor do mundo em um ambiente de computação público transparente e unificado que opera na velocidade da web com capacidade ilimitada, permitindo aos empreendedores e desenvolvedores para reinventar a maneira como construímos tudo.
The Complete Internet Computer Blockchain Trinity – Bitcoin, Ethereum e Internet Computer – marcando as três principais inovações na tecnologia de blockchain. Essas três redes descentralizadas se complementam e têm finalidades diferentes: Bitcoin (criptomoeda), Ethereum (contratos inteligentes) e Internet Computer (computador blockchain).
Uma descrição de computador da Internet (ICP)
Uma explicação da infraestrutura da plataforma de desenvolvimento e como as caixas de software permitem que os serviços da web sejam escalados para bilhões de usuários.
Antes desta ocasião importante, queremos oferecer ao público uma visão de alto nível sobre como a rede funciona.
Sistema nervoso em rede
O computador da Internet é baseado em um protocolo de computador blockchain denominado Internet Computer Protocol (ICP). A própria rede é construída a partir de uma hierarquia de blocos de construção. Na parte inferior, estão os data centers separados que hospedam nós de hardware especializados. Essas máquinas de nó são combinadas para criar sub-redes. Caixas de software de host de sub-redes, que são unidades computacionais interoperáveis que os usuários baixam e contêm código e status.
Uma das coisas que torna o ICP único é o Network Nervous System (NNS), que é responsável por controlar, configurar e gerenciar a rede.
Os data centers ingressam na rede solicitando o NNS, que é responsável por induzir os data centers. Embora o próprio NNS tenha um sistema governamental aberto, ele supervisiona as permissões para participar da rede. Em certo sentido, ele desempenha uma função equivalente à da ICANN na Internet, que, entre outras coisas, atribui números de sistema autônomo àqueles que desejam executar roteadores BGP. O NNS executa uma ampla gama de funções de gerenciamento de rede, incluindo o monitoramento de máquinas de nó quanto a discrepâncias estatísticas na rede de computadores da Internet, o que pode indicar desempenho insatisfatório ou comportamento defeituoso.
O NNS também desempenha um papel fundamental na economia simbólica da rede. O NNS gera novos tokens ICP (anteriormente conhecidos como tokens DFN) para recompensar nós gerenciados por data centers e neurônios que votam dentro do NNS, é assim que ele decide quais propostas são enviadas a ele. Quando o NNS cria novos tokens ICP para recompensar data centers e neurônios, isso é inflacionário.
Com o tempo, os proprietários de neurônios e data centers podem pegar seus tokens e resgatá-los com proprietários e gerentes de caixas. Proprietários e gerentes de canisters pegam esses tokens e os transformam em ciclos e usam esses ciclos para carregar seus canisters. Quando esses cartuchos realizam cálculos ou armazenam memória, por exemplo, eles acabam durante os ciclos e, eventualmente, precisam ser recarregados com mais ciclos para continuar funcionando. É deflacionário.
Sub-redes
Para entender o computador da Internet, você precisa entender o conceito de sub-redes, que são a força vital de toda a rede. Uma sub-rede é responsável por hospedar um subconjunto separado de contêineres de software hospedados na rede de computadores da Internet. Uma sub-rede é criada reunindo máquinas de nós de diferentes centros de dados de maneira controlada pelo NNS. Essas máquinas de nó colaboram por meio da PKI para replicar simetricamente os dados e cálculos relacionados às caixas de software que hospedam.
O NNS combina nós de data center independentes criando sub-redes. Isso habilita a matemática do protocolo ICP para garantir que as sub-redes sejam à prova de adulteração e imparáveis, usando tecnologia de tolerância a falhas bizantina e criptografia desenvolvida por DFINITY. Embora as sub-redes sejam os blocos de construção fundamentais da rede geral de computadores da Internet, elas são transparentes para os usuários e o software. Os usuários e o software do Canister só precisam saber a identidade de um Canister para chamar funções compartilhadas.
Essa transparência é uma extensão dos princípios fundamentais de design da Internet. Na Internet, se um usuário deseja se conectar a determinado software, tudo o que ele precisa fazer é saber o endereço IP da máquina que executa o software e a porta TCP que o software está escutando. No computador da Internet, se um usuário deseja chamar uma função, tudo o que ele precisa fazer é saber a identidade do destinatário e a assinatura da função. Da mesma forma que a Internet cria conectividade contínua, DFINITY criou um mundo perfeito para software, onde qualquer software autorizado pode chamar qualquer outro software diretamente sem saber nada sobre o funcionamento subjacente da rede.
O computador da Internet também fornece transparência da sub-rede de outras maneiras. O NNS pode dividir e mesclar sub-redes, por exemplo, para equilibrar a carga em toda a rede. Isso também é transparente para contêineres hospedados.
Neste exemplo, temos uma sub-rede imaginária, ABC, que abriga 11 contêineres. O NNS diz a ele para se separar. A sub-rede ABC continua com Canisters 1–6 e uma nova sub-rede é gerada, Subnet XYZ, que continua com Canisters 7-11. Nenhum dos navios em questão terá sofrido interrupção do serviço.
Ao baixar suas latas da Internet para o computador, você precisa direcionar um tipo específico de sub-rede. Na verdade, há uma sub-rede especial que hospeda o NNS, mas não pode carregar seus contêineres nela. Em vez disso, ele deve apontar para algum tipo de sub-rede, como “dados”, “sistema” ou “fiat”.
Cada tipo de sub-rede oferece ao destinatário certas propriedades e recursos. Por exemplo, se o seu destinatário estiver hospedado em uma sub-rede de dados, ele pode lidar com chamadas, mas não pode fazer chamadas para outros destinatários. Para isso, você precisará de uma sub-rede do sistema. Se você deseja que seu canister seja capaz de manter saldos de tokens ICP ou enviar ciclos para outros canisters, você precisará de uma sub-rede fiat. E, por esses motivos, os contêineres de governança só podem ser hospedados em sub-redes fiat.
Os recursos das sub-redes são em parte derivados da tolerância a falhas subjacente. Esta é uma área científica subjacente realmente empolgante que esperamos compartilhar com o público em um futuro próximo, incluindo uma nova criptografia que permite ao NNS consertar sub-redes quebradas.
Barcos
O objetivo de uma sub-rede é hospedar contêineres. Canisters são executados em hipervisores dedicados e interagem uns com os outros por meio de uma API especificada publicamente. Dentro de uma caixa está um bytecode WebAssembly que pode ser executado em uma máquina virtual WebAssembly e nas páginas de memória nas quais é executado. Normalmente, este bytecode WebAssembly terá sido criado compilando uma linguagem de programação, como Rust ou Motoko. Este bytecode terá um runtime integrado que permite ao desenvolvedor interagir facilmente com a API.
Observação: o código de amostra mostrado aqui é um pseudocódigo.
No computador da Internet, as funções compartilhadas pelos destinatários devem ser chamadas de duas maneiras. Eles podem ser chamados como uma chamada de atualização ou uma chamada de solicitação. A principal diferença é que quando você chama uma função como uma chamada de atualização, as mudanças feitas nos dados na memória da caixa são preservadas, enquanto se uma função for chamada como uma chamada de consulta, as mudanças feitas serão ignoradas. memória de. depois de executado.
As chamadas de atualização fazem alterações persistentes e também são à prova de adulteração, pois são executadas pelos protocolos de computação ICP blockchain em todos os nós da sub-rede. Não é novidade que as chamadas são executadas em uma ordem de chamada geral consistente, usando mecanismos que permitem a execução simultânea em um ambiente de execução totalmente determinístico. Atualize todas as chamadas em apenas dois segundos.
Neste exemplo, o usuário envia um pedido de compra para uma troca financeira hospedada em um contêiner.
As consultas, por outro lado, não retêm alterações. Quaisquer alterações feitas na memória serão descartadas após serem executadas. Eles são muito eficientes, baratos e completos em milissegundos. Isso ocorre porque eles não são executados em todos os nós da sub-rede, o que também significa que oferecem um nível inferior de segurança.
Neste exemplo, o usuário solicita um feed de notícias personalizado e obtém o conteúdo recém-gerado quase imediatamente.
Persistência ortogonal
Uma das coisas mais interessantes sobre o computador da Internet é a maneira como os desenvolvedores armazenam dados. Os desenvolvedores não precisam pensar em persistência, eles apenas escrevem seu código e a persistência acontece automaticamente. Isso é chamado de persistência ortogonal. Isso ocorre porque o computador da Internet preserva as páginas de memória nas quais o código é executado.
Você pode estar se perguntando como tudo funciona. No que diz respeito às chamadas de atualização que podem alterar as páginas de memória, os contêineres são reprodutores de software. Isso significa que só pode haver um encadeamento de execução em uma caixa por vez.
Embora haja apenas um encadeamento de execução em um Canister, as chamadas de atualização do Canister cruzado podem ser intercaladas por padrão. Isso acontece quando as chamadas de atualização fazem chamadas de atualização entre contêineres, que bloqueiam, permitindo que o thread de execução alterne para uma nova chamada de atualização.
Em contraste, as chamadas de consulta não fazem alterações persistentes na memória. E permite que qualquer número de threads simultâneos processem chamadas de consulta em um cartucho a qualquer momento. Essas chamadas de consulta são feitas em relação ao instantâneo da memória salvo na última raiz de estado concluída.
Finalmente, nenhuma discussão sobre barcos estaria completa sem mencionar que os barcos podem criar novos barcos e que os barcos podem ramificar-se. Você pode criar um novo cartucho apenas especificando o bytecode WebAssembly e as páginas de memória começam vazias. Quando uma caixa se bifurca, uma cópia recém-gerada é criada, idêntica às páginas de memória que ela contém. A bifurcação é muito poderosa na criação de serviços de Internet escalonáveis.
Escalabilidade
Agora vem uma explicação de alto nível sobre a evolução dos serviços de Internet. Os jackpots têm limites superiores em seus diferentes tipos de capacidade. Por exemplo, um Canister pode armazenar apenas 4 GB de páginas de memória devido a limitações nas implementações do WebAssembly. Por esse motivo, quando queremos criar serviços de Internet que chegam a bilhões de usuários, temos que usar arquiteturas de vários contêineres.
Esperamos que seja suficiente criar um contêiner especial, fazer muitas cópias do contêiner e, em seguida, fragmentar o conteúdo do usuário entre os diferentes contêineres para criar um serviço de Internet que possa ser escalado. Infelizmente, essa arquitetura é muito simples por vários motivos.
É verdade que cada contêiner adicional aumenta a capacidade geral da memória. Também é verdade que cada cartucho adicional aumenta a atualização geral e o desempenho de chamada de consulta. Mas não podemos escalar solicitações de chamada de consulta para conteúdo de usuário específico. Também precisamos reequilibrar o conteúdo do usuário toda vez que aumentamos a capacidade do sistema adicionando mais fragmentos de caixa, e isso não é realmente uma grande arquitetura de borda. Também não há uma maneira óbvia de lidar com chamadas de solicitação para usuários finais de espelhos próximos a eles. Precisaremos de barcos de entrada e barcos de fundo.
O computador da Internet fornece funcionalidades interessantes para conectar usuários finais a containers front-end. Um deles permite que nomes de domínio sejam atribuídos a vários contêineres de front-end por meio do NNS. Quando um usuário final deseja resolver esse nome de domínio, o computador da Internet examina todos os nós de réplica em todas as sub-redes que hospedam os contêineres de Front End e retorna os endereços IP dos nós de réplica mais próximos. Isso resulta no usuário final executando chamadas de consulta em réplicas próximas, reduzindo a latência de rede inerente e melhorando a experiência do usuário, oferecendo os benefícios da computação de ponta sem uma rede de distribuição de conteúdo.
Para obter o máximo dessa funcionalidade, precisamos de uma arquitetura clássica que envolva contêineres de front-end e contêineres de dados de back-end. Neste exemplo, um navegador da web deseja carregar uma imagem de perfil.
Primeiro, o navegador da web mapeará para um contêiner de front-end em execução em uma sub-rede com um nó próximo. O navegador da web enviará uma solicitação de chamada de solicitação para recuperar a foto neste nó próximo.
O contêiner front-end fará uma solicitação de chamada de consulta entre contêineres para o contêiner de dados que contém a foto.
Se a resposta à invocação da consulta retornada pelo contêiner do data warehouse incluir conteúdo estático, como uma foto, os dados podem ser armazenados em cache. Nesses casos, o nó de réplica que executa a chamada de consulta do contêiner de front-end pode colocar a resposta da chamada de consulta em seu cache de consulta.
Obviamente, o mecanismo para armazenar chamadas de solicitação é completamente transparente para o código do contêiner de front-end. Depois que o contêiner de front-end que o usuário chamou coletou todas as informações necessárias, ele pode retornar o conteúdo, seja por meio de uma resposta a uma chamada de solicitação ou por meio de um endpoint HTTP.
Com o tempo, os caches de consulta de nó acumulam conteúdo estático e geram dados de interesse para usuários próximos, proporcionando-lhes uma experiência de usuário melhor e mais rápida. Dessa forma, a arquitetura de borda nativa do computador da Internet oferece os benefícios de uma rede de distribuição de conteúdo, mas sem que os desenvolvedores precisem fazer nada de especial e sem a necessidade de ajuda, um serviço proprietário separado.
Para chamadas de atualização, a arquitetura clássica tem uma abordagem diferente. As atualizações de conteúdo e dados de um usuário devem ser serializadas para evitar problemas como a falta de atualizações. Isso geralmente é feito atribuindo um usuário a um contêiner de front-end específico simplesmente digitando seu nome de usuário, por exemplo.
Depois que uma UX / UI em execução em um navegador da web ou smartphone determina qual contêiner de front-end é responsável por coordenar as alterações em determinado conteúdo ou dados, ele pode alterar esse conteúdo ou dados enviando uma chamada de atualização atualizado para sua interface padrão.
Esse contêiner de front-end normalmente faz mais chamadas de atualização entre contêineres para fazer as alterações necessárias.
Serviços de Internet abertos
Para resumir tudo, vamos discutir o projeto de um serviço de Internet aberto usando nossa arquitetura de duas camadas com contêineres de front-end e contêineres de dados de back-end. Em primeiro lugar, quando você escreve o código do contêiner de front-end, sua vida fica mais fácil usando a classe de biblioteca existente chamada BigMap.
O BigMap pode armazenar exabytes de dados e você pode gravar objetos nele usando uma única linha de código. Essa arquitetura evoluirá de forma transparente e dinâmica, tendo contêineres front-end e contêineres de dados para distribuir a responsabilidade por objetos atribuídos a um contêiner entre dois contêineres.
Finalmente, para criar um verdadeiro serviço de Internet aberta, você atribuirá a responsabilidade por todos os seus destinatários a um destinatário simbolizado de governo aberto. Se você for um empresário, estará levantando fundos para o desenvolvimento vendendo alguns desses tokens de governança no início. E você provavelmente irá projetar sistemas que irão incentivar seu serviço de Internet desde o início, dando-lhes tokens de governança para melhores efeitos de rede e ganhos.
