Installazione con un host bastion

Puoi utilizzare un host bastion per eseguire un'installazione air - gapped di API Connect su Red Hat OpenShift Container Platform (OCP) quando il tuo cluster non dispone di connettività internet.

Prima di iniziare

Questa attività deve essere eseguita dall'amministratore Red Hat OpenShift .

Informazioni su questa attività

Se il tuo cluster non è connesso a Internet, puoi eseguire il mirroring delle immagini del prodotto in un registro nel tuo ambiente limitato alla rete utilizzando un host bastion. Un host bastion ha accesso sia all'internet pubblico che all'ambiente limitato alla rete in cui risiedono i cluster di destinazione. È possibile recuperare le immagini del prodotto da internet e trasmetterle a un registro locale; quindi è possibile estrarre le immagini dal registro locale al cluster di destinazione per l'installazione.

Procedura

Impostare l'ambiente di mirroring.

Preparare il cluster di destinazione:
- Distribuisce una versione supportata di Red Hat OpenShift Container Platform (OCP) come cluster.
  Per informazioni, consultare la Tabella 2 "Matrice di compatibilitàAPI Connect e OpenShift Container Platform (OCP) " in IBM API Connect Versione 10.
- Configurare l'archiviazione sul cluster e verificare che sia disponibile.

Prepara il bastion host:

Devi essere in grado di connettere il tuo host bastion a Internet e all'ambiente di rete limitato (con accesso al cluster Red Hat OpenShift Container Platform (OCP) e al registro locale) contemporaneamente. Il proprio host deve trovarsi su una piattaforma Linux x86_64 o Mac con qualsiasi altro sistema operativo supportato da Red Hat OpenShift Client (in Windows, eseguire le azioni in una VM Linux x86_64 o da un terminale Windows Subsystem for Linux ).

Assicurati che i siti e le porte elencati nella Tabella 1 possano essere raggiunti dall'host bastion:

Tabella 1. Siti che devono essere raggiunti dall'host bastion
Sito	Descrizione
`icr.io:443`	Registro autorizzato IBM
`quay.io:443`	Repository di immagine API Connect locale
`github.com`	Strumenti e file CASE
`redhat.com`	Aggiornamenti Red Hat OpenShift Container Platform (OCP)

Sull'host bastion, installare Docker o Podman (non entrambi).
Docker e Podman vengono utilizzati per gestire i contenitori; devi solo installare una di queste applicazioni.
- Per installare Docker (ad esempio, su Red Hat Enterprise Linux), eseguire questi comandi:
```
yum check-update
yum install docker
```
- Per installare Podman, vedi le istruzioni di installazione diPodman.
  Ad esempio, su Red Hat Enterprise Linux 9, installare Podman con il seguente comando:
```
yum install podman
```
Installa lo strumento Red Hat OpenShift Client (oc) come descritto in Introduzione alla CLI OpenShift.
Lo strumento oc viene utilizzato per gestire le risorse Red Hat OpenShift nel cluster.
Scarica la IBM Catalog Management Plug-in for IBM Cloud Paks versione 1.1.0 o successiva da GitHub.
Il plug-in ibm-pak ti consente di accedere alle immagini del prodotto ospitate ed eseguire i comandi oc ibm-pak sul cluster. Per confermare che ibm-pak è installato, immetti il seguente comando e verifica che la risposta elenchi l'utilizzo del comando:
```
oc ibm-pak --help
```

Configurare un registro immagini locale e le credenziali.
Il registro Docker locale memorizza le immagini di mirroring nel tuo ambiente limitato alla rete.
1. Installare un registro o ottenere l'accesso a un registro esistente.
  Potresti già avere accesso a uno o più server del registro aziendale centralizzati per memorizzare le immagini API Connect . In caso contrario, è necessario installare e configurare un registro di livello di produzione prima di procedere.
  Il prodotto del registro utilizzato deve soddisfare i requisiti seguenti:
  - Supporta immagini multi - architettura tramite Docker Manifest V2, Schema 2
    Per i dettagli, vedi Docker Manifest V2, Schema 2.
  - È accessibile dai nodi cluster Red Hat OpenShift Container Platform
  - Consente i separatori di percorso nel nome immagine
  Nota: non utilizzare il registro delle immagini Red Hat OpenShift come registro locale perché non supporta le immagini a più architetture o i separatori di percorsi nel nome immagine.
2. Configurare il registro per soddisfare i seguenti requisiti:
  - Supporta la creazione automatica del repository
  - Dispone di memoria sufficiente per contenere tutto il software che deve essere trasferito
  - Dispone delle credenziali di utente che può creare e scrivere nei repository (il processo di mirroring utilizza queste credenziali)
  - ha le credenziali di un utente che può leggere tutti i repository (il cluster Red Hat OpenShift Container Platform utilizza queste credenziali)
Per accedere ai tuoi registri durante un'installazione con air - gapping, utilizza un account che possa scrivere nel registro locale di destinazione. Per accedere ai tuoi registri durante il runtime, utilizza un account che può leggere dal registro locale di destinazione.

Mirroring dell'operatore cert - manager per Red Hat OpenShift.
Eseguire il mirroring dell'operatore come descritto nelle istruzioni Red Hat : Mirroring delle immagini per un'installazione scollegata utilizzando il plugin oc - mirror .
Quando si modifica il ImageSetConfiguration, includere openshift-cert-manager-operator nel canale stable-v1 come uno dei package, come mostrato nel seguente esempio:
```
    packages:
    - name: openshift-cert-manager-operator
      channels:
      - name: stable-v1
```
Impostare le variabili di ambiente e scaricare file CASE .

Poiché utilizzerai i valori da due diversi file CASE , devi creare le variabili di ambiente per entrambi; nota che le variabili per i servizi fondamentali (servizi comuni) CASE hanno come prefisso "CS_" per differenziarli.

Importante: a partire da API Connect 10.0.11.0, le immagini EDB sono incluse nel pacchetto di custodie API Connect e non richiedono un'installazione separata. Per le versioni precedenti a 10.0.11.0, è necessario installare e configurare manualmente il caso EDB.
1. Creare le seguenti variabili di ambiente con il nome immagine del programma di installazione e l'inventario immagini sul proprio host:
  - API Connect:
```
export CASE_NAME=ibm-apiconnect
export CASE_VERSION=6.2.0
export ARCH=amd64
```
    Per informazioni sulle versioni di API Connect CASE e sugli operatori e operandi corrispondenti, vedere Requisiti degli operatori, di CASE e della piattaforma.
  - Servizi di base:
```
export CS_CASE_NAME=ibm-cp-common-services
export CS_CASE_VERSION=4.6.18+
export CS_ARCH=amd64
```
    Per informazioni sulle versioni IBM Cloud Pak foundational services (servizi comuni) CASE , consultare " Tabella 1. Versioni dell'immagine per l'installazione offline" in Installazione dei servizi fondamentali di IBM Cloud Pak in un ambiente protetto dall'aria, nella documentazione di IBM Cloud Pak foundational services .
  - DataPower:
```
export DP_CASE_NAME=ibm-datapower-operator
export DP_CASE_VERSION=1.16.0
export DP_ARCH=amd64
```
2. Collegare l'host a internet (non è necessario che sia connesso all'ambiente limitato alla rete in questo momento).
3. Scaricare i file CASE sul proprio dispositivo portatile:
  - API Connect:
```
oc ibm-pak get $CASE_NAME --version $CASE_VERSION
```
  - Servizi di base:
```
oc ibm-pak get $CS_CASE_NAME --version $CS_CASE_VERSION
```
  - DataPower
```
oc ibm-pak get $DP_CASE_NAME --version $DP_CASE_VERSION
```
Mirror delle immagini.

Il processo di mirroring delle immagini estrae le immagini da Internet e le invia al registro locale. Dopo aver eseguito il mirroring delle tue immagini, puoi configurare il tuo cluster ed eseguirne il pull delle immagini prima di installare API Connect.
1. Genera manifest mirror.
  1. Definire la variabile di ambiente $TARGET_REGISTRY immettendo il seguente comando:
```
export TARGET_REGISTRY=<target-registry>
```
    Sostituire <target-registry> con l'indirizzo IP (o il nome host) e la porta del registro locale; ad esempio: 172.16.0.10:5000. Se si desidera che le immagini utilizzino uno spazio dei nomi specifico nel registro di destinazione, è possibile specificarlo qui; ad esempio: 172.16.0.10:5000/registry_ns.
  2. Generare i file manifest di mirroring immettendo i seguenti comandi:
    - API Connect:
      oc ibm-pak generate mirror-manifests $CASE_NAME --version $CASE_VERSION $TARGET_REGISTRY
    - Servizi di base:
      oc ibm-pak generate mirror-manifests $CS_CASE_NAME --version $CS_CASE_VERSION $TARGET_REGISTRY
    - DataPower:
      oc ibm-pak generate mirror-manifests $DP_CASE_NAME file://integration --version $DP_CASE_VERSION --final-registry $TARGET_REGISTRY
    Se devi filtrare per uno specifico gruppo di immagini, aggiungi il parametro --filter <image_group> al comando.
  Il comando generate crea i seguenti file: ~/.ibm-pak/data/mirror/$CASE_NAME/$CASE_VERSION, e ~/.ibm-pak/data/mirror/$CS_CASE_NAME/$CS_CASE_VERSION:
  - catalog-sources.yaml
  - catalog-sources-linux-<arch>.yaml (se sono presenti origini di catalogo specifiche dell'architettura)
  - image-content-source-policy.yaml
  - images-mapping.txt
  I file vengono utilizzati durante il mirroring delle immagini in TARGET_REGISTRY.
2. Ottenere una chiave di titolarità per il registro autorizzato in cui sono ospitate le immagini:
  1. Accedere alla libreria di contenitori IBM.
  2. Nella libreria software del contenitore, selezionare Richiama chiave di titolarità.
  3. Nella sezione "Accedi al tuo software contenitore", fai clic su Copia chiave.
  4. Copia la chiave in una posizione sicura; la utilizzerai per accedere a cp.icr.io nel passo successivo.
3. Autenticarsi con il registro autorizzato in cui si trovano le immagini.
  Il segreto di pull dell'immagine ti consente di autenticarti con il registro autorizzato e accedere alle immagini del prodotto.
  1. Immetti il seguente comando per esportare il percorso nel file che memorizzerà le credenziali di autenticazione generate su un accesso Podman o Docker :
```
export REGISTRY_AUTH_FILE=$HOME/.docker/config.json
```
    Il file di autenticazione si trova in genere in $HOME/.docker/config.json su Linux o %USERPROFILE%/.docker/config.json su Windows.
  2. Accedere al registro cp.icr.io con Podman o Docker; ad esempio:
```
podman login cp.icr.io
```
    Utilizzare cp come nome utente e la chiave di titolarità come password.
4. Autenticarsi con il registro locale.
  Accedere al registro locale utilizzando un account che può scrivere immagini in tale registro; ad esempio:
```
podman login $TARGET_REGISTRY
```
  Se il registro non è sicuro, aggiungere il seguente indicatore al comando: --tls-verify=false.
5. Aggiorna il manifest CASE per fare riferimento correttamente all'immagine DataPower Operator .
  
  I file per Operatore DataPower sono ora ospitati su icr.io; tuttavia, il manifest CASE fa ancora riferimento a docker.io come host dell'immagine. Per risolvere questo problema, visitare il sito Airgap install failure due to 'unable to retrieve source image docker.io ' nella documentazione DataPower e aggiornare il manifest come indicato. Una volta aggiornato il manifest, continuare con il passo successivo in questa procedura.
6. Mirror delle immagini del prodotto.
  1. Connetti il bastion host sia all'ambiente internet che alla rete limitata che contiene il registro locale.
  2. Esegui i comandi seguenti per copiare le immagini nel registro locale:
    - API Connect:
      oc image mirror \ -f ~/.ibm-pak/data/mirror/$CASE_NAME/$CASE_VERSION/images-mapping.txt \ -a $REGISTRY_AUTH_FILE \ --filter-by-os '.*' \ --skip-multiple-scopes \ --max-per-registry=1
    - Servizi di base:
      oc image mirror \ -f ~/.ibm-pak/data/mirror/$CS_CASE_NAME/$CS_CASE_VERSION/images-mapping.txt \ -a $REGISTRY_AUTH_FILE \ --filter-by-os '.*' \ --skip-multiple-scopes \ --max-per-registry=1
    - DataPower:
      oc image mirror \ -f ~/.ibm-pak/data/mirror/$DP_CASE_NAME/$DP_CASE_VERSION/images-mapping.txt \ -a $REGISTRY_AUTH_FILE \ --filter-by-os '.*' \ --skip-multiple-scopes \ --max-per-registry=1 \
    Nota: se il registro locale non è protetto da TLS o se il certificato presentato dal registro locale non è considerato attendibile dal tuo dispositivo, aggiungi l'opzione --insecure al comando.
    
    Potrebbe verificarsi un leggero ritardo prima di visualizzare una risposta al comando.
7. Configurare il cluster di destinazione.
  Ora che le immagini sono state sottoposte a mirroring nel registro locale, il cluster di destinazione deve essere configurato per eseguire il pull delle immagini da esso. Completa la seguente procedura per configurare il segreto di pull globale del cluster con credenziali del registro locale e quindi indica al cluster di estrarre le immagini dal registro locale.
  1. Accedi al cluster Red Hat OpenShift Container Platform :
```
oc login <openshift_url> -u <username> -p <password> -n <namespace>
```
  2. Aggiornare il segreto di estrazione dell'immagine globale per il cluster, come spiegato nella documentazione di Red Hat OpenShift Container Platform .
    Nota: se hai un registro non sicuro, aggiungi il registro all'elenco insecureRegistries del cluster immettendo il seguente comando:
    oc edit image.config.openshift.io/cluster -o yaml
    e aggiungere TARGET_REGISTRY a spec.registrySources.insecureRegistries come mostrato nel seguente esempio:
    spec: registrySources: insecureRegistries: - insecure0.svc:5001 - <TARGET_REGISTRY>
    Se il campo insecureRegistries non esiste, è possibile aggiungerlo.
  3. Creare l'indirizzo ImageContentSourcePolicy, che indica al cluster di prelevare le immagini dal registro locale:
    - API Connect:
      oc apply -f ~/.ibm-pak/data/mirror/$CASE_NAME/$CASE_VERSION/image-content-source-policy.yaml
    - Servizi di base:
      oc apply -f ~/.ibm-pak/data/mirror/$CS_CASE_NAME/$CS_CASE_VERSION/image-content-source-policy.yaml
    - DataPower:
      oc apply -f ~/.ibm-pak/data/mirror/$DP_CASE_NAME/$DP_CASE_VERSION/image-content-source-policy.yaml
  4. Verificare che la risorsa ImageContentSourcePolicy sia stata creata:
```
oc get imageContentSourcePolicy
```
  5. Verificare lo stato del nodo cluster:
```
oc get MachineConfigPool -w
```
    Attendere l'aggiornamento di tutti i nodi prima di procedere al passo successivo.
Applicare le origini del catalogo.

Ora che hai eseguito il mirroring delle immagini nel cluster di destinazione, applica le origini del catalogo per i servizi API Connect e Foundational. Non è necessario applicare l'origine catalogo per EDB perché l'operatore API Connect applicherà tale origine catalogo nel suo spazio dei nomi quando viene creato l'operando API Connect .

Nei passi successivi, sostituire <Architecture> con amd64, s390x o ppc64le , a seconda dell'ambiente.
1. Esportare le variabili per la riga comandi da utilizzare:
```
export CASE_NAME=ibm-apiconnect
export CASE_VERSION=6.2.0
export ARCH=amd64
```
```
export CS_CASE_NAME=ibm-cp-common-services
export CS_CASE_VERSION=4.6.18+
export CS_ARCH=amd64
```
```
export DP_CASE_NAME=ibm-datapower-operator
export DP_CASE_VERSION=1.16.0
export DP_ARCH=amd64
```
2. Generare le origini del catalogo e salvarle in un'altra directory nel caso in cui sia necessario replicare questa installazione in futuro.
  1. Ottieni le origini del catalogo:
```
cat ~/.ibm-pak/data/mirror/${CASE_NAME}/${CASE_VERSION}/catalog-sources.yaml
```
```
cat ~/.ibm-pak/data/mirror/${CS_CASE_NAME}/${CS_CASE_VERSION}/catalog-sources.yaml
```
```
cat ~/.ibm-pak/data/mirror/${DP_CASE_NAME}/${DP_CASE_VERSION}/catalog-sources.yaml
```
  È anche possibile passare alla directory nel browser di file per copiare queste risorse utente in file che è possibile conservare per il riutilizzo o per le pipeline.
3. Applica le origini del catalogo al cluster.
  1. Applicare le origini del catalogo universale:
```
oc apply -f ~/.ibm-pak/data/mirror/${CASE_NAME}/${CASE_VERSION}/catalog-sources.yaml
```
```
oc apply -f ~/.ibm-pak/data/mirror/${CS_CASE_NAME}/${CS_CASE_VERSION}/catalog-sources.yaml
```
```
oc apply -f ~/.ibm-pak/data/mirror/${DP_CASE_NAME}/${DP_CASE_VERSION}/catalog-sources.yaml
```
  2. Conferma che le origini del catalogo sono state create nello spazio dei nomi openshift-marketplace :
```
oc get catalogsource -n openshift-marketplace
```

Cosa fare successivamente

Installare API Connect seguendo i passaggi relativi al tipo di distribuzione: Distribuzione su OpenShift e Cloud Pak for Integration.