Node.js 23 ಗೆ ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡಿದ ನಂತರ ಗ್ರೆಮ್ಲಿನ್ ನೆಟ್‌ವರ್ಕ್ ದೋಷಗಳನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ

Node.js 23 ರಲ್ಲಿ ಗ್ರೆಮ್ಲಿನ್ ಸಂಪರ್ಕ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸುವುದು

Amazon Neptune ನಂತಹ ಡೇಟಾಬೇಸ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಲು Gremlin ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ನಿಮ್ಮ Node.js ಆವೃತ್ತಿಯೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. Node.js ನ ಹೊಸ ಆವೃತ್ತಿಗಳಿಗೆ ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡುವಾಗ ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುತ್ತಾರೆ ಮತ್ತು ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಥಿರತೆಯನ್ನು ಅಡ್ಡಿಪಡಿಸಬಹುದು.

ಗೆ ಅಪ್ಗ್ರೇಡ್ ಮಾಡುವ ಸಂದರ್ಭದಲ್ಲಿ Node.js 23, ಕೆಲವು ಬಳಕೆದಾರರು ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆ ಅಥವಾ 101 ಅಲ್ಲದ ಸ್ಥಿತಿ ಕೋಡ್ ಒಳಗೊಂಡಿರುವ ನಿರ್ದಿಷ್ಟ ದೋಷವನ್ನು ಎದುರಿಸಿದ್ದಾರೆ. ಈ ಸಮಸ್ಯೆಯು ಹಿಂದಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಇರುವುದಿಲ್ಲ, ಉದಾಹರಣೆಗೆ Node.js 20.18, ಅಲ್ಲಿ ಸಂಪರ್ಕವು ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. Node.js ಕೋರ್ ಘಟಕಗಳಲ್ಲಿನ ಬದಲಾವಣೆಯು ಈ ಸಮಸ್ಯೆಯ ಮೂಲವಾಗಿರಬಹುದು.

ಹಳೆಯ ಆವೃತ್ತಿಗಳಿಗೆ ಹಿಂತಿರುಗಿಸದೆ, Node.js 23 ನ ಇತ್ತೀಚಿನ ವೈಶಿಷ್ಟ್ಯಗಳಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಲು ಬಯಸುವ ಯಾರಿಗಾದರೂ ಈ ದೋಷವನ್ನು ಪರಿಹರಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಗ್ರೆಮ್ಲಿನ್ ಸಂಪರ್ಕದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವಂತಹ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ಪರಿಹರಿಸುವುದು ಸುಗಮ ಕಾರ್ಯಾಚರಣೆಗೆ ಅತ್ಯಗತ್ಯ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ನಾವು ದೋಷವನ್ನು ವಿವರವಾಗಿ ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಅದರ ಕಾರಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು Amazon ನೆಪ್ಚೂನ್‌ಗಾಗಿ Gremlin ಪ್ಯಾಕೇಜ್‌ನೊಂದಿಗೆ Node.js 23 ಅನ್ನು ಬಳಸುವಾಗ ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತೇವೆ.

Node.js 23 ರಲ್ಲಿ ಗ್ರೆಮ್ಲಿನ್ ನೆಟ್‌ವರ್ಕ್ ದೋಷಗಳನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ

ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಗುರಿಯನ್ನು ಹೊಂದಿದೆ ದೂರಸ್ಥ ಸಂಪರ್ಕ ಗ್ರೆಮ್ಲಿನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು Node.js ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು Amazon ನೆಪ್ಚೂನ್ ನಡುವೆ. ಪರಿಹಾರದ ತಿರುಳು ಬಳಸುವುದರಲ್ಲಿದೆ ಡ್ರೈವರ್ ರಿಮೋಟ್ ಕನೆಕ್ಷನ್ ಮತ್ತು ಇದರೊಂದಿಗೆ ಅಡ್ಡಹಾಯುವ ವಸ್ತುವನ್ನು ರಚಿಸುವುದು Graph.traversal().withRemote(). ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ರಾವರ್ಸಲ್ ಆಬ್ಜೆಕ್ಟ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ, ನೆಪ್ಚೂನ್‌ಗೆ ಸಂಪರ್ಕದೊಂದಿಗೆ ಒಂದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು ಕೇವಲ ಒಂದು ಸಂಪರ್ಕವನ್ನು ತೆರೆಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಟ್ರೈ-ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಸಂಪರ್ಕ ದೋಷಗಳನ್ನು ಆಕರ್ಷಕವಾಗಿ ನಿರ್ವಹಿಸಲು ಒಂದು ರಕ್ಷಣಾತ್ಮಕ ಸಾಧನವಾಗಿದೆ, ದೋಷವನ್ನು ಲಾಗ್ ಮಾಡುವುದು ಮತ್ತು ಏನಾದರೂ ತಪ್ಪಾದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಯಿಂದ ನಿರ್ಗಮಿಸುತ್ತದೆ.

ಎರಡನೆಯ ಪರಿಹಾರವು ವೆಬ್‌ಸಾಕೆಟ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಮೊದಲನೆಯದನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ನ ಸೇರ್ಪಡೆ ಹೊಸ WebSocket() ಅಮೆಜಾನ್ ನೆಪ್ಚೂನ್‌ನೊಂದಿಗೆ ಹೆಚ್ಚು ಸ್ಥಿರವಾದ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಇದು ನೈಜ-ಸಮಯದ ಡೇಟಾ ವಿನಿಮಯವನ್ನು ಅವಲಂಬಿಸಿರುವ ಪರಿಸರದಲ್ಲಿ ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಸಂಪರ್ಕದಲ್ಲಿ WebSocket ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸುವ ಮೂಲಕ, Node.js 23 ರಲ್ಲಿ ಸಂಭವಿಸುವ 101 ಅಲ್ಲದ ಸ್ಥಿತಿ ಕೋಡ್ ದೋಷದ ಸಂಭಾವ್ಯ ಮೂಲವನ್ನು ನಾವು ಪರಿಹರಿಸುತ್ತೇವೆ. ಈ WebSocket ಏಕೀಕರಣವು ಅತ್ಯಗತ್ಯ ಏಕೆಂದರೆ ಹೊಸ Node.js ಆವೃತ್ತಿಗಳು ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳನ್ನು ವಿಭಿನ್ನವಾಗಿ ನಿರ್ವಹಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ HTTP ವಿನಂತಿಗಳಿಗಾಗಿ ಬಳಸಲಾಗುವ ಆಂತರಿಕ undici ಲೈಬ್ರರಿ.

ಮೂರನೆಯ ಪರಿಹಾರವು a ಅನ್ನು ಒಳಗೊಂಡಿದೆ ತರ್ಕವನ್ನು ಮರುಪ್ರಯತ್ನಿಸಿ ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆ. ಈ ವಿಧಾನವು ನೆಟ್ವರ್ಕ್ ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವಕ್ಕೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಆರಂಭಿಕ ಸಂಪರ್ಕ ಪ್ರಯತ್ನ ವಿಫಲವಾದಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಪ್ರಯತ್ನಗಳವರೆಗೆ ಸಂಪರ್ಕವನ್ನು ಮರುಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಅಪ್ಲಿಕೇಶನ್‌ನ ದೃಢತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ಮರುಪ್ರಯತ್ನದ ಮಾದರಿಯು ತಾತ್ಕಾಲಿಕ ನೆಟ್‌ವರ್ಕ್ ಅಸ್ಥಿರತೆ ಅಥವಾ ಸರ್ವರ್-ಸೈಡ್ ಸಮಸ್ಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಒಂದೇ ಸಂಪರ್ಕದ ಸಮಸ್ಯೆಯಿಂದಾಗಿ ಅಪ್ಲಿಕೇಶನ್ ವಿಫಲವಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಸಂಪರ್ಕವನ್ನು ಮಾಡುವವರೆಗೆ ಅಥವಾ ಮರುಪ್ರಯತ್ನದ ಮಿತಿಯನ್ನು ತಲುಪುವವರೆಗೆ ಲೂಪ್ ಮಾಡುವ ಅಸಮಕಾಲಿಕ ಕ್ರಿಯೆಯೊಂದಿಗೆ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ, ನೆಪ್ಚೂನ್ ತಲುಪಲಾಗದಿದ್ದರೆ ಸ್ಪಷ್ಟ ನಿರ್ಗಮನ ತಂತ್ರವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಎಲ್ಲಾ ಮೂರು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಭದ್ರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ತಿರಸ್ಕರಿಸು ಅನಧಿಕೃತ: ತಪ್ಪು SSL ಪ್ರಮಾಣಪತ್ರ ಮೌಲ್ಯೀಕರಣವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಇದು ಕೆಲವು ಅಭಿವೃದ್ಧಿ ಅಥವಾ ಪರೀಕ್ಷಾ ಪರಿಸರದಲ್ಲಿ ಅಗತ್ಯವಾಗಬಹುದು ಆದರೆ ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸಬೇಕು. ನೆಪ್ಚೂನ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಾಗಿ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳ ಬಳಕೆಯು ಅಪ್ಲಿಕೇಶನ್‌ನ ಸುರಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಹಾರ್ಡ್-ಕೋಡ್ ಮಾಡಲಾಗಿಲ್ಲ. ಈ ಪ್ರತಿಯೊಂದು ವಿಧಾನಗಳು ವಿಭಿನ್ನ ಪರಿಸರಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಭಿನ್ನ ಪರಿಹಾರಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅಪ್ಲಿಕೇಶನ್ ಸಂಪರ್ಕ ಸಮಸ್ಯೆಗಳನ್ನು ಆಕರ್ಷಕವಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ ಮತ್ತು ಇತ್ತೀಚಿನ Node.js ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

import { DriverRemoteConnection } from 'gremlin';
import { Graph } from 'gremlin/lib/structure/graph';
let g: any = null;
export function getGremlinTraversal() {
  if (!g) {
    const neptuneEndpoint = process.env.NEPTUNE_DB_ENDPOINT || '';
    try {
      const dc = new DriverRemoteConnection(neptuneEndpoint, { rejectUnauthorized: false });
      const graph = new Graph();
      g = graph.traversal().withRemote(dc);
    } catch (err) {
      console.error('Connection Error:', err.message);
      process.exit(1);
    }
  }
  return g;
}

import { DriverRemoteConnection } from 'gremlin';
import { Graph } from 'gremlin/lib/structure/graph';
import { WebSocket } from 'ws';
let g: any = null;
export function getGremlinTraversal() {
  if (!g) {
    const neptuneEndpoint = process.env.NEPTUNE_DB_ENDPOINT || '';
    try {
      const ws = new WebSocket(neptuneEndpoint, { rejectUnauthorized: false });
      const dc = new DriverRemoteConnection(neptuneEndpoint, { webSocket: ws });
      const graph = new Graph();
      g = graph.traversal().withRemote(dc);
    } catch (err) {
      console.error('WebSocket Error:', err.message);
      process.exit(1);
    }
  }
  return g;
}

import { DriverRemoteConnection } from 'gremlin';
import { Graph } from 'gremlin/lib/structure/graph';
let g: any = null;
async function retryConnection(retries: number) {
  let attempt = 0;
  while (attempt < retries) {
    try {
      const neptuneEndpoint = process.env.NEPTUNE_DB_ENDPOINT || '';
      const dc = new DriverRemoteConnection(neptuneEndpoint, { rejectUnauthorized: false });
      const graph = new Graph();
      g = graph.traversal().withRemote(dc);
      break;
    } catch (err) {
      attempt++;
      console.error(`Attempt ${attempt}: Connection Error`, err.message);
      if (attempt >= retries) process.exit(1);
    }
  }
}
export function getGremlinTraversal() {
  if (!g) { retryConnection(3); }
  return g;
}

Node.js 23 ರಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ರೋಟೋಕಾಲ್ ಬದಲಾವಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸಲಾಗುತ್ತಿದೆ

ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಒಂದು ಪ್ರಮುಖ ಅಂಶ Node.js 23 ಆಂತರಿಕ ಗ್ರಂಥಾಲಯಗಳು ಹೇಗೆ undici, ನೆಟ್ವರ್ಕ್ ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಿ. 101 ಅಲ್ಲದ ಸ್ಥಿತಿ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ Amazon ನೆಪ್ಚೂನ್‌ಗೆ ಸಂಪರ್ಕಿಸುವಾಗ ಎದುರಾಗುವ ದೋಷವು, WebSocket ಮತ್ತು HTTP ಸಂಪರ್ಕಗಳನ್ನು Node.js ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಬದಲಾವಣೆಗಳಿಗೆ ಆಗಾಗ್ಗೆ ಲಿಂಕ್ ಮಾಡಬಹುದು. ಈ ಪ್ರೋಟೋಕಾಲ್ ಹೊಂದಾಣಿಕೆಗಳು ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸುರಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸುವ ಉದ್ದೇಶವನ್ನು ಹೊಂದಿವೆ, ಆದರೆ ಅವುಗಳು ಹೊಂದಾಣಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಚಯಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿರುವ ಗ್ರೆಮ್ಲಿನ್‌ನಂತಹ ಪ್ಯಾಕೇಜ್‌ಗಳೊಂದಿಗೆ.

Node.js 20.18 ಗೆ ಡೌನ್‌ಗ್ರೇಡ್ ಮಾಡುವುದರಿಂದ ಸಮಸ್ಯೆಯನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಪರಿಹರಿಸಬಹುದು, ಹೊಸ ಆವೃತ್ತಿಗಳಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್-ಸಂಬಂಧಿತ ಬದಲಾವಣೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವುದು ದೀರ್ಘಾವಧಿಯ ಸ್ಥಿರತೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. HTTP ಮತ್ತು WebSocket ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಹೊಂದಿರುವ undici ಲೈಬ್ರರಿಯು ಕಟ್ಟುನಿಟ್ಟಾದ SSL ಜಾರಿ ಮತ್ತು ವರ್ಧಿತ ದೋಷ-ನಿರ್ವಹಣೆ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಗಮನಾರ್ಹ ಸುಧಾರಣೆಗಳಿಗೆ ಒಳಗಾಗಿದೆ. ಅಮೆಜಾನ್ ನೆಪ್ಚೂನ್ ಅಥವಾ ಅಂತಹುದೇ ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳು ಸಂವಹನದಲ್ಲಿ ಅಡಚಣೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಈ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ತಮ್ಮ ಸಂಪರ್ಕ ಪ್ರೋಟೋಕಾಲ್‌ಗಳನ್ನು ಜೋಡಿಸಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.

ಹೆಚ್ಚುವರಿಯಾಗಿ, Node.js ನಲ್ಲಿ ಭದ್ರತಾ ಅಭ್ಯಾಸಗಳನ್ನು ಬಲಪಡಿಸಲಾಗಿದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ವೆಬ್‌ಸಾಕೆಟ್ ಸಂಪರ್ಕಗಳಲ್ಲಿ ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಹೇಗೆ ಮೌಲ್ಯೀಕರಿಸಲಾಗುತ್ತದೆ. ಹಿಂದೆ ಒದಗಿಸಿದ ಪರಿಹಾರಗಳಲ್ಲಿ ಗಮನಿಸಿದಂತೆ, ಬಳಸಿ ತಿರಸ್ಕರಿಸು ಅನಧಿಕೃತ: ತಪ್ಪು SSL ಮೌಲ್ಯೀಕರಣವನ್ನು ಬೈಪಾಸ್ ಮಾಡಬಹುದು, ಇದು ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿದೆ ಆದರೆ ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಅಪಾಯಕಾರಿಯಾಗಿದೆ. ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ಸಿಸ್ಟಂಗಳನ್ನು ಹೊಸ ಭದ್ರತಾ ಮಾನದಂಡಗಳಿಗೆ ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಗುರಿಯನ್ನು ಹೊಂದಿರಬೇಕು ಮತ್ತು ಅಮೆಜಾನ್ ನೆಪ್ಚೂನ್‌ನಂತಹ ಬಾಹ್ಯ ಸೇವೆಗಳಿಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಸಂಪರ್ಕವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳಬೇಕು, ಭದ್ರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಎರಡನ್ನೂ ಸಮತೋಲಿತವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.