#Terminal

Oi pessoal!  Esse artigo é para quem está começando com InterSystems IRIS. Espero que ajude!

O InterSystems IRIS é uma plataforma de dados unificada: uma base de dados de alta performance com ferramentas de interoperabilidade e análise integradas em um só produto. Você tem SQL e NoSQL na mesma máquina, além de jeitos nativos de rodar Python com seus dados. Em resumo: menos peças móveis, mais capacidade de processamento.

Por que engenheiros escolhem IRIS

Você está curioso para saber como executar scripts Python diretamente no terminal do InterSystems IRIS ou Caché? 🤔
Boa notícia: é fácil! 😆
O IRIS oferece suporte ao Embedded Python, permitindo que você use Python de forma interativa dentro do terminal do IRIS.

Como acessar o Shell do Python?

Para iniciar o shell do Python a partir do terminal do IRIS, basta executar o seguinte comando:

do##class(%SYS.Python).Shell()

Esse comando abre um shell interativo do Python dentro do terminal do IRIS. A partir daí, você pode escrever e executar código Python como faria em um ambiente Python normal.

Existe algum comando que retorna a quantidade de linhas de uma global?

Exemplo:

^test(1)="aa"
^test(2)="aa"
^test(3)="aa"
^test(4)="aa"
Total de linhas = 4

Bom dia. Comecei a estudar o Caché a menos de um mês, de lá pra cá testei várias funcionalidades mas há uma que eu não consegui encontrar. Como posso fazerem meus dados serem responsivos quando representados em tabelas no terminal?

Exemplo (dados fictícios):

Você já editou arquivos no VS Code, mas precisou verificar um valor global ou executar alguns comandos do ObjectScript? Agora você pode, sem necessidade de configuração! Se você tem vscode-objectscript extension version 2.10.0 ou posterior e estiver conectado ao InterSystems IRIS 2023.2 ou posterior, agora você pode abrir uma conexão de terminal com seu servidor, independentemente de onde ele esteja localizado.

Existem três maneiras de abrir este novo terminal:

• O comando "Iniciar Terminal WebSocket" na paleta de comandos (Ctrl-Shift-P no Windows, Cmd-Shift-P no Mac):

• O terminal integrado do VS Code Menu Perfis:

*A extensão do Gerenciador de Servidores árvore do servidor:

O Terminal WebSocket oferece suporte a muitos dos recursos do [shell ObjectScript] padrão(https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=GCLI_intro) como leituras, trocas de namespace, interrupções e prompts de terminal personalizados. Porém, neste post gostaria de destacar três recursos que são exclusivos dele.

• A entrada do comando tem sintaxe colorida, então você pode ter certeza de que sua entrada está sintaticamente correta antes de executar:

• O terminal suporta um modo de edição multilinha, onde uma nova linha será adicionada ao pressionar Enter em vez de executar a entrada. Uma nova linha será adicionada se houver chave esquerda não fechada { ou parêntese esquerdo ( na entrada do comando:

• Está totalmente integrado com o VS Code integração de shell, então o VS Code captura a entrada e a saída do comando. Isso permite que você execute comandos novamente e copie a saída do comando para a área de transferência sem ter que destacar o texto com o cursor:

Para obter uma lista completa de recursos, consulte a documentação oficial. Tem uma ideia de como podemos melhorar esse recurso? Estamos felizes em ouvir isso! Poste suas sugestões no [repositório GitHub] da extensão(https://github.com/intersystems-community/vscode-objectscript/issues). Todas as capturas de tela desta postagem usam o novo tema VS Code "InterSystems Default Dark Modern", que está disponível na extensão InterSystems Language Server versão 2.4.0 e posterior.

Preciso fazer  o seguinte exercício:

"Crie uma regra/método que solicite 10 números ao usuário e no final apresente-os em tela, ordenados do menor para o maior."

Porém já li e reli a documentação, e não consigo entender como criar regra/método no Caché.

Eu crio conforme a doc, mas não executa nada quando chamo a rotina no terminal.

Alguém pode me ajudar por favor?

Tentei function, procedure e subroutine também.

Temos um delicioso conjunto de dados com receitas escritas por vários usuários do Reddit, porém, a maioria das informações é texto livre, como o título ou a descrição de um post. Vamos descobrir como carregar o conjunto de dados facilmente, extrair algumas características e analisá-las usando recursos do modelo de linguagem grande da OpenAI no Embedded Python e no framework Langchain.

Carregando o conjunto de dados

Primeiro de tudo, precisamos carregar o conjunto de dados ou podemos só nos conectar a ele?

Há diferentes maneiras de alcançar isso: por exemplo, é possível usar o CSV Record Mapper em uma produção de interoperabilidade ou até em aplicativos legais do OpenExchange, como csvgen.

Vamos usar o Foreign Tables. Um recurso bastante útil para projetar dados armazenados fisicamente em outro lugar no IRIS SQL. Podemos usar isso para ter uma primeira visão dos arquivos do conjunto de dados.

Criamos um Foreign Server:

CREATE FOREIGN SERVER dataset FOREIGN DATA WRAPPER CSV HOST '/app/data/'

E, em seguida, uma Foreign Table que se conecta ao arquivo CSV:

CREATE FOREIGN TABLE dataset.Recipes (
  CREATEDDATE DATE,
  NUMCOMMENTS INTEGER,
  TITLE VARCHAR,
  USERNAME VARCHAR,
  COMMENT VARCHAR,
  NUMCHAR INTEGER
) SERVER dataset FILE 'Recipes.csv' USING
{
  "from": {
    "file": {
       "skip": 1
    }
  }
}

É isso, imediatamente podemos executar consultas SQL em "dataset.Recipes":

## Quais dados são necessários? O conjunto de dados é interessante e estamos com fome. No entanto, se quisermos decidir uma receita para cozinhar, será preciso mais algumas informações que possamos usar para análise.

Vamos trabalhar com duas classes persistentes (tabelas):

• yummy.data.Recipe: uma classe que contém o título e a descrição da receita e algumas outras propriedades que queremos extrair e analisar, por exemplo, Score, Difficulty, Ingredients, CuisineType, PreparationTime (nota, dificuldade, ingredientes, tipo de culinária, tempo de preparo)
• yummy.data.RecipeHistory: uma classe simples para registrar o que estamos fazendo com a receita

Podemos agora carregar nossas tabelas "yummy.data*" com o conteúdo do conjunto de dados:

do ##class(yummy.Utils).LoadDataset()

Parece bom, mas ainda precisamos descobrir como vamos gerar os dados para os campos Score, Difficulty, Ingredients, PreparationTime e CuisineType.

## Analise as receitas Queremos processar cada título e descrição de receita e:

• Extrair informações como Difficulty, Ingredients, CuisineType etc.
• Criar nossa própria nota com base em nossos critérios para que possamos decidir o que queremos cozinhar.

Vamos usar o seguinte:

• yummy.analysis.Analysis - uma estrutura de análise genérica que podemos reutilizar para desenvolver mais análises.
• yummy.analysis.SimpleOpenAI - uma análise que usar o Embedded Python + framework Langchain + modelo LLM da OpenAI.

LLM (modelos de linguagem grande) são realmente uma ótima ferramenta para processar linguagem natural.

LangChain está pronto para uso no Python, então podemos usá-lo diretamente no InterSystems IRIS usando o Embedded Python.

A classe "SimpleOpenAI" completa fica assim:

/// Análise simples da OpenAI para receitas
Class yummy.analysis.SimpleOpenAI Extends Analysis
{

Property CuisineType As %String;

Property PreparationTime As %Integer;

Property Difficulty As %String;

Property Ingredients As %String;

/// Execute
/// Você pode tentar isto a partir de um terminal:
/// set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8))
/// do a.Run()
/// zwrite a
Method Run()
{
    try {
        do ..RunPythonAnalysis()

        set reasons = ""

        // meus tipos de culinária favoritos
        if "spanish,french,portuguese,italian,korean,japanese"[..CuisineType {
            set ..Score = ..Score + 2
            set reasons = reasons_$lb("It seems to be a "_..CuisineType_" recipe!")
        }

        // não quero passar o dia todo cozinhando :)
        if (+..PreparationTime < 120) {
            set ..Score = ..Score + 1
            set reasons = reasons_$lb("You don't need too much time to prepare it") 
        }
        
        // bônus para ingredientes favoritos!
        set favIngredients = $listbuild("kimchi", "truffle", "squid")
        for i=1:1:$listlength(favIngredients) {
            set favIngred = $listget(favIngredients, i)
            if ..Ingredients[favIngred {
                set ..Score = ..Score + 1
                set reasons = reasons_$lb("Favourite ingredient found: "_favIngred)
            }
        }

        set ..Reason = $listtostring(reasons, ". ")

    } catch ex {
        throw ex
    }
}

/// Atualize a receita com o resultado da análise
Method UpdateRecipe()
{
    try {
        // chame a implementação de classe mãe primeiro
        do ##super()

        // adicione resultados de análises da OpenAI específicos
        set ..Recipe.Ingredients = ..Ingredients
        set ..Recipe.PreparationTime = ..PreparationTime
        set ..Recipe.Difficulty = ..Difficulty
        set ..Recipe.CuisineType = ..CuisineType

    } catch ex {
        throw ex
    }
}

/// Execute a análise usando o embedded Python + Langchain
/// do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8)).RunPythonAnalysis(1)
Method RunPythonAnalysis(debug As %Boolean = 0) [ Language = python ]
{
    # load OpenAI APIKEY from env
    import os
    from dotenv import load_dotenv, find_dotenv
    _ = load_dotenv('/app/.env')

    # account for deprecation of LLM model
    import datetime
    current_date = datetime.datetime.now().date()
    # date after which the model should be set to "gpt-3.5-turbo"
    target_date = datetime.date(2024, 6, 12)
    # set the model depending on the current date
    if current_date > target_date:
        llm_model = "gpt-3.5-turbo"
    else:
        llm_model = "gpt-3.5-turbo-0301"

    from langchain.chat_models import ChatOpenAI
    from langchain.prompts import ChatPromptTemplate
    from langchain.chains import LLMChain

    from langchain.output_parsers import ResponseSchema
    from langchain.output_parsers import ResponseSchema

    # init llm model
    llm = ChatOpenAI(temperature=0.0, model=llm_model)

    # prepare the responses we need
    cuisine_type_schema = ResponseSchema(
        name="cuisine_type",
        description="What is the cuisine type for the recipe? \
                     Answer in 1 word max in lowercase"
    )
    preparation_time_schema = ResponseSchema(
        name="preparation_time",
        description="How much time in minutes do I need to prepare the recipe?\
                     Anwer with an integer number, or null if unknown",
        type="integer",
    )
    difficulty_schema = ResponseSchema(
        name="difficulty",
        description="How difficult is this recipe?\
                     Answer with one of these values: easy, normal, hard, very-hard"
    )
    ingredients_schema = ResponseSchema(
        name="ingredients",
        description="Give me a comma separated list of ingredients in lowercase or empty if unknown"
    )
    response_schemas = [cuisine_type_schema, preparation_time_schema, difficulty_schema, ingredients_schema]

    # get format instructions from responses
    output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
    format_instructions = output_parser.get_format_instructions()
    
    analysis_template = """\
    Interprete and evaluate a recipe which title is: {title}
    and the description is: {description}
    
    {format_instructions}
    """
    prompt = ChatPromptTemplate.from_template(template=analysis_template)

    messages = prompt.format_messages(title=self.Recipe.Title, description=self.Recipe.Description, format_instructions=format_instructions)
    response = llm(messages)

    if debug:
        print("======ACTUAL PROMPT")
        print(messages[0].content)
        print("======RESPONSE")
        print(response.content)

    # populate analysis with results
    output_dict = output_parser.parse(response.content)
    self.CuisineType = output_dict['cuisine_type']
    self.Difficulty = output_dict['difficulty']
    self.Ingredients = output_dict['ingredients']
    if type(output_dict['preparation_time']) == int:
        self.PreparationTime = output_dict['preparation_time']

    return 1
}

}

O método "RunPythonAnalysis" é onde tudo relacionado a OpenAI acontece :). Você pode executá-lo diretamente no terminal para uma receita específica:

do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)

Vamos obter uma saída assim:

USER>do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)
======ACTUAL PROMPT
                    Interprete and evaluate a recipe which title is: Folded Sushi - Alaska Roll
                    and the description is: Craving for some sushi but don't have a sushi roller? Try this easy version instead. It's super easy yet equally delicious!
[Video Recipe](https://www.youtube.com/watch?v=1LJPS1lOHSM)
# Ingredients
Serving Size:  \~5 sandwiches      
* 1 cup of sushi rice
* 3/4 cups + 2 1/2 tbsp of water
* A small piece of konbu (kelp)
* 2 tbsp of rice vinegar
* 1 tbsp of sugar
* 1 tsp of salt
* 2 avocado
* 6 imitation crab sticks
* 2 tbsp of Japanese mayo
* 1/2 lb of salmon  
# Recipe     
* Place 1 cup of sushi rice into a mixing bowl and wash the rice at least 2 times or until the water becomes clear. Then transfer the rice into the rice cooker and add a small piece of kelp along with 3/4 cups plus 2 1/2 tbsp of water. Cook according to your rice cookers instruction.
* Combine 2 tbsp rice vinegar, 1 tbsp sugar, and 1 tsp salt in a medium bowl. Mix until everything is well combined.
* After the rice is cooked, remove the kelp and immediately scoop all the rice into the medium bowl with the vinegar and mix it well using the rice spatula. Make sure to use the cut motion to mix the rice to avoid mashing them. After thats done, cover it with a kitchen towel and let it cool down to room temperature.
* Cut the top of 1 avocado, then slice into the center of the avocado and rotate it along your knife. Then take each half of the avocado and twist. Afterward, take the side with the pit and carefully chop into the pit and twist to remove it. Then, using your hand, remove the peel. Repeat these steps with the other avocado. Dont forget to clean up your work station to give yourself more space. Then, place each half of the avocado facing down and thinly slice them. Once theyre sliced, slowly spread them out. Once thats done, set it aside.
* Remove the wrapper from each crab stick. Then, using your hand, peel the crab sticks vertically to get strings of crab sticks. Once all the crab sticks are peeled, rotate them sideways and chop them into small pieces, then place them in a bowl along with 2 tbsp of Japanese mayo and mix until everything is well mixed.
* Place a sharp knife at an angle and thinly slice against the grain. The thickness of the cut depends on your preference. Just make sure that all the pieces are similar in thickness.
* Grab a piece of seaweed wrap. Using a kitchen scissor, start cutting at the halfway point of seaweed wrap and cut until youre a little bit past the center of the piece. Rotate the piece vertically and start building. Dip your hand in some water to help with the sushi rice. Take a handful of sushi rice and spread it around the upper left hand quadrant of the seaweed wrap. Then carefully place a couple slices of salmon on the top right quadrant. Then place a couple slices of avocado on the bottom right quadrant. And finish it off with a couple of tsp of crab salad on the bottom left quadrant. Then, fold the top right quadrant into the bottom right quadrant, then continue by folding it into the bottom left quadrant. Well finish off the folding by folding the top left quadrant onto the rest of the sandwich. Afterward, place a piece of plastic wrap on top, cut it half, add a couple pieces of ginger and wasabi, and there you have it.
                    
                    A saída deve ser um fragmento de código markdown formatado no seguinte esquema, incluindo o "```json" e "```" à esquerda e à direita:
json
{
        "cuisine_type": string  // What is the cuisine type for the recipe?                                  Answer in 1 word max in lowercase
        "preparation_time": integer  // How much time in minutes do I need to prepare the recipe?                                    Anwer with an integer number, or null if unknown
        "difficulty": string  // How difficult is this recipe?                               Answer with one of these values: easy, normal, hard, very-hard
        "ingredients": string  // Give me a comma separated list of ingredients in lowercase or empty if unknown
}

                    
======RESPONSE
json
{
        "cuisine_type": "japanese",
        "preparation_time": 30,
        "difficulty": "easy",
        "ingredients": "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
}

Tudo bem. Parece que nosso prompt da OpenAI é capaz de retornar algumas informações úteis. Vamos executar toda a classe da análise no terminal:

set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12))
do a.Run()
zwrite a

USER>zwrite a
a=37@yummy.analysis.SimpleOpenAI  ; <OREF>
+----------------- general information ---------------
|      oref value: 37
|      class name: yummy.analysis.SimpleOpenAI
| reference count: 2
+----------------- attribute values ------------------
|        CuisineType = "japanese"
|         Difficulty = "easy"
|        Ingredients = "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
|    PreparationTime = 30
|             Reason = "It seems to be a japanese recipe!. You don't need too much time to prepare it"
|              Score = 3
+----------------- swizzled references ---------------
|           i%Recipe = ""
|           r%Recipe = "30@yummy.data.Recipe"
+-----------------------------------------------------

## Analisando todas as receitas! Naturalmente, você gostaria de executar a análise em todas as receitas que carregamos.

Você pode analisar uma variedade de IDs de receitas desta forma:

USER>do ##class(yummy.Utils).AnalyzeRange(1,10)
> Recipe 1 (1.755185s)
> Recipe 2 (2.559526s)
> Recipe 3 (1.556895s)
> Recipe 4 (1.720246s)
> Recipe 5 (1.689123s)
> Recipe 6 (2.404745s)
> Recipe 7 (1.538208s)
> Recipe 8 (1.33001s)
> Recipe 9 (1.49972s)
> Recipe 10 (1.425612s)

Depois disso, verifique novamente sua tabela de receitas e confira os resultados

select * from yummy_data.Recipe

Acho que eu poderia tentar a pizza de abóbora ou o tofu com kimchi coreano e porco :). Vou precisar conferir novamente em casa de qualquer forma :)

Observações finais

Encontre o exemplo completo em https://github.com/isc-afuentes/recipe-inspector

Com esse exemplo simples, aprendemos a usar as técnicas de LLM para adicionar recursos ou analisar partes dos seus dados no InterSystems IRIS.

Com esse ponto de partida, você pode pensar em:

• Usar a BI do InterSystems para explorar e navegar pelos seus dados usando cubos e painéis.
• Criar um webapp e fornecer IU (por exemplo, Angular). Para isso, você pode aproveitar pacotes como RESTForms2 para gerar automaticamente as APIs REST para suas classes persistentes.
• Armazenar as receitas independentemente de gostar delas e, depois, tentar determinar se uma nova receita gostará de você? Você pode tentar uma abordagem com o IntegratedML ou até mesmo um LLM, fornecendo alguns dados de exemplo e criando um caso de uso de RAG (Geração Aumentada de Recuperação).

O que mais você pode tentar? Me diga o que você acha!

Introdução

Como a InterSystems anunciou recentemente a descontinuação do suporte ao InterSystems Studio a partir da versão 2023.2 em favor do desenvolvimento exclusivo de extensões para o IDE do Visual Studio Code (VSC), acreditando que este oferece uma experiência superior em comparação com o Studio, vários desenvolvedores migraram ou estão começando a usar o VSC. Vários talvez tenham se perguntado sobre como abrir o terminal para realizar operações, já que o VSC não tem um painel de saída como o Studio nem um recurso integrado para abrir o terminal IRIS, exceto baixando os plug-ins desenvolvidos pela InterSystems.

Resumo

• Introdução 
• Soluções
  • Para usuários com, no mínimo, IRIS 2020.1 ou IRIS 2021.1.2  – Use Web Terminal
  • Para usuários com, no mínimo, IRIS 2023.2 – Use WebSocket Terminal
  • Para usuários com o IRIS baseado em Docker
  • Para usuários com versões do IRIS anteriores à 2023.2 trabalhando em suas máquinas locais
  • Para usuários programando no IRIS com base em um servidor remoto usando uma conexão SSH

Soluções

Há várias maneiras de abrir o terminal no VSC, dependendo da configuração específica que você estiver usando. Resumi aqui as melhores soluções para qualquer situação:

Para usuários com, no mínimo, IRIS 2020.1.1 ou IRIS 2021.1.2 – Use Web Terminal

Usuários que têm, no mínimo, o IRIS 2020.1.1 ou IRIS 2021.1.2 e podem instalar extensões externas (alguém pode não ter permissão para isso devido à política da empresa em relação a aplicativos de terceiros) podem achar útil a extensão Web Terminal para VSC. Para quem não sabe, Web Terminal é um terminal baseado na Web para os produtos da InterSystems desenvolvidos com ObjectScript (por exemplo, IRIS, Caché, Ensemble, HealthShare e TrakCare) que permite usar uma versão mais avançada do terminal dentro do navegador (página do projeto). Essa extensão do VSC possibilita inicializar um terminal baseado na Web diretamente do VSC, com um simples clique.

Para abrir o Web Terminal, clique em: InterSystems Tools (Ferramentas da InterSystems)  > selecione um namespace > clique em um dos seguintes ícones (, ) para abrir o Web Terminal em um painel de terminal do VSC ou no navegador (pressione Alt para mudar o ícone padrão):

Para usuários com, no mínimo, IRIS 2023.2 – Use WebSocket Terminal

Usuários com, no mínimo, IRIS 2023.2 podem se beneficiar do novo recurso "WebSocket Terminal" incluso na versão mais recente das extensões do VSC e não precisam de alternativas adicionais.

Para abrir o WebSocket Terminal, clique em: InterSystems Tools > selecione um namespace > clique no ícone ao lado do correspondente ao Web Terminal.

Para usuários com IRIS baseado em Docker

Quem trabalha com ambientes do IRIS no Docker e usa o VSC pode iniciar uma sessão de terminal diretamente no ambiente do Docker.  

Clique na voz do Docker na Barra de status e selecione Open Terminal in Docker (Abrir terminal no Docker).

Quero agradecer @Evgeny Shvarov pela foto e explicação sobre esse ponto.

Para usuários com versões do IRIS anteriores à 2023.2 trabalhando nas suas máquinas locais

Para usuários que trabalham com uma versão do IRIS executada na máquina local, é possível configurar um terminal do IRIS dedicado no VSC:

1. 1. Abra o arquivo settings.json. Você pode encontrá-lo de várias maneiras, por exemplo, clicando em View (Ver) > Command Palette (Paleta de comandos) > digite: "settings" (configurações) > Open User Settings (JSON) (Abrir configurações do usuário)
   2. Adicione o seguinte código em "terminal.integrated.profiles.windows":

"terminal.integrated.profiles.windows":{
<span class="hljs-string">"IRIS Terminal"</span>: {

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"path"</span>: [

&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <span class="hljs-string">"C:\\InterSystems\\IRISHealth\\bin\\irissession.exe"</span>
&nbsp;&nbsp;&nbsp; ],

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"args"</span>: [<span class="hljs-string">"IRISHEALTH"</span>],

&nbsp;&nbsp;&nbsp; <span class="hljs-string">"icon"</span>: <span class="hljs-string">"terminal-cmd"</span>
} 
}

Observação: insira o caminho correto do seu irissession.exe.

c. Para abrir o terminal a partir do VSC, navegue até: Terminal > New Terminal (Novo terminal) > Launch Profile… (Inicializar perfil) > IRIS Terminal.

d. Uma voz "IRIS Terminal" deve agora estar disponível no menu Terminal:

Para usuários programando no IRIS com base em um servidor remoto usando uma conexão SSH 

Para quem trabalha em uma versão do IRIS baseada em um servidor remoto (por exemplo, o servidor de uma empresa) acessível por conexão SSH (por exemplo, usando PuTTY), é possível usar a extensão Remote - SSH VSC para conectar o VSC diretamente ao servidor. Para fazer isso:

1. 1. Instale a extensão Remote - SSH: Editing Configuration Files no VSC;
   2. Clique no ícone "Remote Explorer" (Explorador remoto) na barra lateral;
   3. Selecione "Open SSH Config File" (Abrir arquivo de configuração SSH)

e abra o arquivo de configuração com o caminho: C:\Users\<username>\.ssh\config

1. 4. Insira o seguinte código no arquivo de configuração: 

Host my-putty-connection
    HostName < IP address or server name >
    User < username >
    IdentityFile < private key path on your local machine >
    Port < port > 

O endereço IP e a porta correspondem ao nome do host e à porta especificada em PuTTY, o nome de usuário é a credencial de usuário usada para acessar o servidor remoto, e IdentityFile é o caminho do arquivo para a chave privada de PuTTY.

Observação:  o formato original da chave privada gerada por PuTTY (.ppk) não pode ser lido pelo VSC. Para estabelecer uma conexão entre o VSC e o servidor remoto via PuTTY, você precisa duplicar a chave privada original e converter a nova versão no formato .pem. Para fazer a conversão:

1. Inicialize o aplicativo PuTTYgen
2. No menu File (Arquivo), clique em "Load private key" (Carregar chave privada)
3. Selecione sua chave privada no formato .ppk e escolha "Open" (Abrir)
4. No menu Conversions (Conversões), clique em "Export OpenSSH Key (force new file format)", ou "Exportar chave OpenSSH (forçar novo formato de arquivo)".
5. Defina um novo nome com a extensão .pem e clique no botão Save (Salvar).
6. Vincule o caminho para esse novo arquivo .pem ao parâmetro IdentifyFile no VSC
   1. Salve o arquivo. Depois de alguns segundos, a nova conexão deve aparecer no painel Remote Explorer;
   2. Clique em "Connect in New Window..." (Conectar em uma nova janela...) para abrir a conexão SSH em uma nova janela do VSC:
7.  Selecione o sistema operacional da sua máquina remota (somente no primeiro acesso)
8. Na nova janela, acesse: Terminal > New Terminal (ou use os atalhos Ctrl + ò ou Ctrl + Shift + ò).
9. Agora você está conectado à máquina remota e pode usar seu Terminal IRIS dentro do VSC.

Observação: essa operação só funciona se você iniciar a conexão remota via PuTTY antes, e não funciona se PuTTY for encerrado ou não estiver conectado ao servidor remoto. Essa operação não inicializa PuTTY, só permite que o VSC se conecte ao túnel estabelecido por PuTTY.

Para iniciar uma conexão PuTTY pelo VSC, você pode utilizar um arquivo de lote (no Windows). O arquivo connect_remote.bat fornecido usa o comando Plink, incluso em PuTTY, para iniciar uma sessão:

@echo off

set SESSION="<your saved session name>"

plink -load %SESSION%

Para iniciar a sessão, basta digitar .\connect_remote.bat no terminal do VSC para abrir a conexão remota e inserir suas credenciais.

Observação: com este último método, você ganha acesso a uma versão do terminal compatível com todos os atalhos do VSC! Bem-vindo de volta, Ctrl+V, e adeus, Shift+Insert 🎉

É possível ativar Ctrl + C / Ctrl + V no Terminal IRIS para Windows.

Para fazer isso, abra o Terminal e selecione Editar> Configurações do usuário e habilite os aceleradores de edição do Windows. Esta configuração especifica se o Terminal habilita os atalhos de edição comuns do Windows (Ctrl + C, Ctrl + V, Ctrl + Shift + V), além dos atalhos de edição básicos do Terminal (Ctrl + Insert e Shift + Insert).

Depois disso, Ctrl + C / Ctrl + V funcionaria.

Além disso, os erros <SYNTAX> após copiar / colar incorreto desaparecem.

Docs.

Estou tentando executar uma tarefa pelo terminal, utilizando:

set test=##class(%SYS.TaskSuper).%New()

d test.RunNow(1), passando o ID da tarefa, para executa-lá, porém ela não executa. 

Qual seria um outro jeito para que eu consiga realizar essa execução pelo terminal? 

Fala galera! Tudo bem?

Quando @Evgeny Shvarov anunciou o primeiro InterSystems IRIS Programming Contest, Comecei a pensar em algumas ideias. 

Coloquei tudo junto nesse aplicativo e o isc-utils é sobre isso:

•  Conversões
  • Temperatura
  • Distância
• Câmbio de Moedas
• Clima

Conversão de Escala de Temperatura

Fala pessoal, tudo bem?

Criar Database, Namespace, Aplicações REST utilizando o Portal de Administração são tarefas super simples!

Você só precisar de alguns poucos cliques, quer dizer, de muitos cliques, talvez até mais cliques do que você gostaria.

Agora, e se eu te contar que você pode trocar todos esses cliques por uma simples linha de comando?!