{"id":3296,"date":"2026-01-23T14:17:30","date_gmt":"2026-01-23T14:17:30","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/01\/23\/how-to-automate-arm-migration-with-docker-mcp-toolkit-vs-code-and-github-copilot\/"},"modified":"2026-01-23T14:17:30","modified_gmt":"2026-01-23T14:17:30","slug":"how-to-automate-arm-migration-with-docker-mcp-toolkit-vs-code-and-github-copilot","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/01\/23\/how-to-automate-arm-migration-with-docker-mcp-toolkit-vs-code-and-github-copilot\/","title":{"rendered":"How to Automate Arm Migration with Docker MCP Toolkit, VS Code, and GitHub Copilot"},"content":{"rendered":"<p><em>This post is a collaboration between Docker and Arm, demonstrating how Docker MCP Toolkit and the Arm MCP Server work together to simplify architecture migrations.<\/em><\/p>\n<p>Moving workloads from x86 to ARM64 architecture has become increasingly important. Organizations seek to reduce cloud costs and improve performance. AWS Graviton, Azure Cobalt, and Google Cloud Axion have made Arm-based computing mainstream, promising 20-40% cost savings and better performance for many workloads.<\/p>\n<p>But here\u2019s the challenge: How do you migrate your applications to Arm without breaking things?<\/p>\n<p>Traditional migration approaches require:<\/p>\n<ul class=\"wp-block-list\">\n<li>Manual code analysis for x86-specific dependencies<\/li>\n<li>Tedious compatibility checks across multiple tools<\/li>\n<li>Manual performance evaluation<\/li>\n<\/ul>\n<p>What if you could orchestrate the entire Arm migration workflow from a single interface? <a href=\"https:\/\/docs.docker.com\/ai\/mcp-catalog-and-toolkit\/toolkit\/\" rel=\"nofollow noopener\" target=\"_blank\">Docker MCP Toolkit<\/a> makes this possible.\u00a0<\/p>\n<p>By connecting specialized Arm migration tools directly to GitHub Copilot, you can automate compatibility analysis, intrinsic conversion, and performance prediction\u2014all through natural conversation in VS Code.<\/p>\n<p>Here\u2019s what that looks like in practice: You ask GitHub Copilot to migrate your legacy C++ application to ARM64. Copilot doesn\u2019t just tell you what needs changing\u2014it actually executes: scanning your code for x86 intrinsics, converting x86 SIMD intrinsics to Arm SIMD intrinsics, updating your Dockerfile, predicting Arm performance improvements, and creating a pull request with all changes. All through natural conversation in VS Code. No manual porting. No up-front architecture expertise required.<\/p>\n<p>If you have questions about any step in the process, you can directly ask Copilot, which will invoke the Arm MCP Server knowledge base tool. The knowledge base has information pulled directly from all Learning Paths on learn.arm.com, as well as knowledge of all Arm intrinsics, and will both summarize that information for you as well as provide links to the concrete documentation that you can peruse yourself.\u00a0<\/p>\n<p>Now you might ask \u2013 \u201cCan\u2019t I just rebuild my Docker image for ARM64?\u201d True, for most applications. But when you hit that one legacy app with hand-optimized x86 assembly, AVX2 intrinsics, or architecture-specific compiler flags? That\u2019s when Docker MCP Toolkit with the <a href=\"https:\/\/developer.arm.com\/community\/arm-community-blogs\/b\/ai-blog\/posts\/introducing-the-arm-mcp-server-simplifying-cloud-migration-with-ai\" rel=\"nofollow noopener\" target=\"_blank\">Arm MCP Server<\/a> becomes essential.<\/p>\n<p>By the end of this guide, you\u2019ll migrate a real-world legacy application\u2014a matrix multiplication benchmark written with AVX2 intrinsics for x86\u2014to ARM64 automatically using GitHub Copilot and Docker MCP Toolkit.<\/p>\n<p>What normally takes 5-7 hours of manual work will take you about 25 to 30 minutes.<\/p>\n<h2 class=\"wp-block-heading\">The Arm Migration Challenge<\/h2>\n<p>Let me show you exactly what we\u2019re solving. Consider a matrix multiplication benchmark originally written for x86-64 with AVX2 optimizations\u2014the kind of code that makes Arm migration painful.<\/p>\n<p>Here\u2019s a Dockerfile that will cause problems when trying to migrate to Graviton:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\nFROM centos:6\n\n# CentOS 6 reached EOL, need to use vault mirrors\nRUN sed -i 's|^mirrorlist=|#mirrorlist=|g' \/etc\/yum.repos.d\/CentOS-Base.repo &amp;&amp; \n    sed -i 's|^#baseurl=http:\/\/mirror.centos.org|baseurl=http:\/\/vault.centos.org|g' \/etc\/yum.repos.d\/CentOS-Base.repo\n\n# Install EPEL repository (required for some development tools)\nRUN yum install -y epel-release &amp;&amp; \n    sed -i 's|^mirrorlist=|#mirrorlist=|g' \/etc\/yum.repos.d\/epel.repo &amp;&amp; \n    sed -i 's|^#baseurl=http:\/\/download.fedoraproject.org\/pub\/epel|baseurl=http:\/\/archives.fedoraproject.org\/pub\/archive\/epel|g' \/etc\/yum.repos.d\/epel.repo\n\n# Install Developer Toolset 2 for better C++11 support (GCC 4.8)\nRUN yum install -y centos-release-scl &amp;&amp; \n    sed -i 's|^mirrorlist=|#mirrorlist=|g' \/etc\/yum.repos.d\/CentOS-SCLo-scl.repo &amp;&amp; \n    sed -i 's|^mirrorlist=|#mirrorlist=|g' \/etc\/yum.repos.d\/CentOS-SCLo-scl-rh.repo &amp;&amp; \n    sed -i 's|^# baseurl=http:\/\/mirror.centos.org|baseurl=http:\/\/vault.centos.org|g' \/etc\/yum.repos.d\/CentOS-SCLo-scl.repo &amp;&amp; \n    sed -i 's|^# baseurl=http:\/\/mirror.centos.org|baseurl=http:\/\/vault.centos.org|g' \/etc\/yum.repos.d\/CentOS-SCLo-scl-rh.repo\n\n# Install build tools\nRUN yum install -y \n    devtoolset-2-gcc \n    devtoolset-2-gcc-c++ \n    devtoolset-2-binutils \n    make \n    &amp;&amp; yum clean all\n\nWORKDIR \/app\nCOPY *.h *.cpp .\/\n\n# AVX2 intrinsics are used in the code\nRUN scl enable devtoolset-2 \"g++ -O2 -mavx2 -o benchmark \n    main.cpp \n    matrix_operations.cpp \n    -std=c++11\"\n\nCMD [\".\/benchmark\"]\n\n<\/pre>\n<\/div>\n<p>Now you might ask why this won\u2019t work on Arm? Looking at this Dockerfile, there are two immediate blockers for Graviton migration:<\/p>\n<ol class=\"wp-block-list\">\n<li><strong>No ARM64 support in base image<\/strong> \u2013 The <code>centos:6<\/code> image was built for x86 only, so this container won\u2019t even start on Arm hardware.<\/li>\n<li><strong>x86-specific compiler flag<\/strong> \u2013 The <code>-mavx2<\/code> flag tells the compiler to use AVX2 vector instructions, which don\u2019t exist on Arm processors.<\/li>\n<\/ol>\n<p>Even experienced developers miss these issues in larger codebases.<\/p>\n<p>The source code uses AVX2 intrinsics for vectorized operations:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\n#include \"matrix_operations.h\"\n#include &lt;iostream&gt;\n#include &lt;random&gt;\n#include &lt;chrono&gt;\n#include &lt;stdexcept&gt;\n#include &lt;immintrin.h&gt;  \/\/ AVX2 intrinsics\n\nMatrix::Matrix(size_t r, size_t c) : rows(r), cols(c) {\n    data.resize(rows, std::vector&lt;double&gt;(cols, 0.0));\n}\n\nvoid Matrix::randomize() {\n    std::random_device rd;\n    std::mt19937 gen(rd());\n    std::uniform_real_distribution&lt;&gt; dis(0.0, 10.0);\n\n    for (size_t i = 0; i &lt; rows; i++) {\n        for (size_t j = 0; j &lt; cols; j++) {\n            data[i][j] = dis(gen);\n        }\n    }\n}\n\nMatrix Matrix::multiply(const Matrix&amp; other) const {\n    if (cols != other.rows) {\n        throw std::runtime_error(\"Invalid matrix dimensions for multiplication\");\n    }\n\n    Matrix result(rows, other.cols);\n\n    \/\/ x86-64 optimized using AVX2 for double-precision\n    for (size_t i = 0; i &lt; rows; i++) {\n        for (size_t j = 0; j &lt; other.cols; j++) {\n            __m256d sum_vec = _mm256_setzero_pd();\n            size_t k = 0;\n\n            \/\/ Process 4 elements at a time with AVX2\n            for (; k + 3 &lt; cols; k += 4) {\n                __m256d a_vec = _mm256_loadu_pd(&amp;data[i][k]);\n                __m256d b_vec = _mm256_set_pd(\n                    other.data[k+3][j],\n                    other.data[k+2][j],\n                    other.data[k+1][j],\n                    other.data[k][j]\n                );\n                sum_vec = _mm256_add_pd(sum_vec, _mm256_mul_pd(a_vec, b_vec));\n            }\n\n            \/\/ Horizontal add using AVX\n            __m128d sum_high = _mm256_extractf128_pd(sum_vec, 1);\n            __m128d sum_low = _mm256_castpd256_pd128(sum_vec);\n            __m128d sum_128 = _mm_add_pd(sum_low, sum_high);\n\n            double sum_arr[2];\n            _mm_storeu_pd(sum_arr, sum_128);\n            double sum = sum_arr[0] + sum_arr[1];\n\n            \/\/ Handle remaining elements\n            for (; k &lt; cols; k++) {\n                sum += data[i][k] * other.data[k][j];\n            }\n\n            result.data[i][j] = sum;\n        }\n    }\n\n    return result;\n}\n\ndouble Matrix::sum() const {\n    double total = 0.0;\n    for (size_t i = 0; i &lt; rows; i++) {\n        for (size_t j = 0; j &lt; cols; j++) {\n            total += data[i][j];\n        }\n    }\n    return total;\n}\n\nvoid benchmark_matrix_ops() {\n    std::cout &lt;&lt; \"n=== Matrix Multiplication Benchmark ===\" &lt;&lt; std::endl;\n\n    const size_t size = 200;\n    Matrix a(size, size);\n    Matrix b(size, size);\n\n    a.randomize();\n    b.randomize();\n\n    auto start = std::chrono::high_resolution_clock::now();\n    Matrix c = a.multiply(b);\n    auto end = std::chrono::high_resolution_clock::now();\n\n    auto duration = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(end - start);\n\n    std::cout &lt;&lt; \"Matrix size: \" &lt;&lt; size &lt;&lt; \"x\" &lt;&lt; size &lt;&lt; std::endl;\n    std::cout &lt;&lt; \"Time: \" &lt;&lt; duration.count() &lt;&lt; \" ms\" &lt;&lt; std::endl;\n    std::cout &lt;&lt; \"Result sum: \" &lt;&lt; c.sum() &lt;&lt; std::endl;\n}\n\n<\/pre>\n<\/div>\n<p>If you look at the following code, you might find that this code is heavily optimized for Intel\/AMD x86 processors and won\u2019t work on Arm.<\/p>\n<ol class=\"wp-block-list\">\n<li><strong>x86-exclusive header<\/strong> \u2013 <code>#include &lt;immintrin.h&gt;<\/code> only exists on x86 systems. Arm uses <code>&lt;arm_neon.h&gt;<\/code> instead.<\/li>\n<li><strong>AVX2 intrinsics throughout<\/strong> \u2013 Every <code>_mm256_*<\/code> function is Intel-specific:<\/li>\n<\/ol>\n<ul class=\"wp-block-list\">\n<li><code>_mm256_setzero_pd()<\/code> \u2013 Creates a 256-bit zero vector (Arm NEON is 128-bit)<\/li>\n<li><code>_mm256_loadu_pd()<\/code> \u2013 Loads 4 doubles at once (NEON loads 2)<\/li>\n<li><code>_mm256_set_pd()<\/code> \u2013 Sets 4 doubles (no direct NEON equivalent)<\/li>\n<li><code>_mm256_add_pd()<\/code> \/ <code>_mm256_mul_pd()<\/code> \u2013 256-bit operations (NEON uses 128-bit)<\/li>\n<li><code>_mm256_extractf128_pd()<\/code> \u2013 Extracts high 128 bits (not needed on NEON)<\/li>\n<\/ul>\n<ol start=\"3\" class=\"wp-block-list\">\n<li><strong>Vector width mismatch<\/strong> \u2013 AVX2 processes 4 doubles per operation, while Arm NEON processes 2. The entire loop structure needs adjustment. (<strong>SVE\/SVE2<\/strong> on newer Arm cores (Neoverse V1\/V2, Graviton 3\/4) provides 256-bit or wider vector-length agnostic (VLA) registers, matching or exceeding AVX2 registers.)<\/li>\n<li><strong>Horizontal reduction logic<\/strong> \u2013 The horizontal add pattern using <code>_mm256_extractf128_pd<\/code> and <code>_mm256_castpd256_pd128<\/code> is x86-specific and must be completely rewritten for Arm SIMD.<\/li>\n<\/ol>\n<p>Manual conversion requires rewriting 30+ lines of intrinsic code, adjusting loop strides, and testing numerical accuracy. This is exactly where automated migration tools become essential.<\/p>\n<p>Each of these issues blocks Arm migration in different ways. Manual migration requires not just converting intrinsics, but also modernizing the entire build infrastructure, finding Arm equivalents, and validating performance. For any substantial codebase, this becomes prohibitively expensive.<\/p>\n<h2 class=\"wp-block-heading\">What GitHub Copilot Can and Can\u2019t Do Without Arm MCP<\/h2>\n<p>Let\u2019s be clear about what changes when you add the Arm MCP Server to Docker MCP Toolkit.<\/p>\n<h3 class=\"wp-block-heading\">Without Arm MCP<\/h3>\n<p>You ask GitHub Copilot to migrate your C++ application from x86 to ARM64. Copilot responds with general advice: \u201cConvert AVX2 intrinsics to NEON\u201d, \u201cUpdate your Dockerfile to use ARM64 base image\u201d, \u201cChange compiler flags\u201d. Then you must manually research NEON equivalents, rewrite hundreds of lines of intrinsic code, update the Dockerfile yourself, hope you got the conversion right, and spend hours debugging compilation errors.<\/p>\n<p>Yes, Copilot can write code. But without specialized tools, it\u2019s guessing based on training data\u2014not using concrete knowledge base documentation or using purpose-built tools to analyze your actual application architecture.<\/p>\n<h3 class=\"wp-block-heading\">With Arm MCP + Docker MCP Toolkit<\/h3>\n<p>You ask GitHub Copilot the same thing. Within minutes, it:<\/p>\n<ol class=\"wp-block-list\">\n<li>Uses <code>check_image<\/code> tool to verify your base image supports ARM64<\/li>\n<li>Runs <code>migrate_ease_scan<\/code> on your actual codebase to find x86-specific code<\/li>\n<li>Uses <code>knowledge_base_search<\/code> to find correct Arm SIMD equivalents for every x86 intrinsic<\/li>\n<li>Converts your code with architecture-specific accuracy<\/li>\n<li>Updates your Dockerfile with Arm-compatible base images<\/li>\n<li>Creates a pull request with all changes.<\/li>\n<\/ol>\n<p>Real code gets scanned. Real intrinsics get converted. Real pull requests appear in your repository. Close VS Code, come back tomorrow, and the migration is ready to test, complete with documentation explaining every change.<\/p>\n<p>The difference? Docker MCP Toolkit gives GitHub Copilot access to actual Arm migration tooling, not just general knowledge about Arm architecture.<\/p>\n<h3 class=\"wp-block-heading\">Why This Is Different from Manual Migration<\/h3>\n<p>You could manually use Arm migration tools: install utilities locally, run checks, research intrinsics, update code. Here\u2019s what that process looks like:<\/p>\n<p><strong>Manual process:<\/strong><\/p>\n<ol class=\"wp-block-list\">\n<li>Install Arm migration tools (15 minutes)<\/li>\n<li>Run compatibility scans (5 minutes)<\/li>\n<li>Research each x86 intrinsic equivalent (30 minutes per intrinsic)<\/li>\n<li>Manually rewrite code (2-3 hours)<\/li>\n<li>Update Dockerfile (15 minutes)<\/li>\n<li>Fix compilation errors (1-2 hours)<\/li>\n<li>Document changes (30 minutes)<\/li>\n<\/ol>\n<p><strong>Total: 5-7 hours per application<\/strong><\/p>\n<p><strong>With Docker MCP Toolkit + Arm MCP:<\/strong><\/p>\n<ol class=\"wp-block-list\">\n<li>Ask GitHub Copilot to migrate (20 minutes)<\/li>\n<li>Review and approve changes (10-20 minutes)<\/li>\n<li>Merge pull request<\/li>\n<\/ol>\n<p><strong>Total: 30-40 minutes per application<\/strong><\/p>\n<h2 class=\"wp-block-heading\"><strong>Setting Up Visual Studio Code with Docker MCP Toolkit<\/strong><\/h2>\n<h3 class=\"wp-block-heading\">Prerequisites<\/h3>\n<p>Before you begin, make sure you have:<\/p>\n<ul class=\"wp-block-list\">\n<li>A machine with 8 GB RAM minimum (16GB recommended)<\/li>\n<li>The latest Docker Desktop release<\/li>\n<li>VS Code with GitHub Copilot extension<\/li>\n<li>GitHub account with personal access token<\/li>\n<\/ul>\n<h3 class=\"wp-block-heading\">Step 1. Enable Docker MCP Toolkit<\/h3>\n<p>Open Docker Desktop and enable the MCP Toolkit from Settings.<\/p>\n<p><strong>To enable:<\/strong><\/p>\n<ol class=\"wp-block-list\">\n<li>Open Docker Desktop<\/li>\n<li>Go to <strong>Settings<\/strong> \u2192 <strong>Beta Features<\/strong><\/li>\n<li>Toggle <strong>Docker MCP Toolkit<\/strong> ON<\/li>\n<\/ol>\n<p>Click <strong>Apply<\/strong><\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1922186844  fetchpriority=\"high\" decoding=\"async\" width=\"1999\" height=\"1031\" src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image15.png\" class=\"fade-in attachment-full size-full\" alt=\"Enabling Docker MCP Toolkit under Docker Desktop\" title=\"- image15\" \/>\n        <\/div>\n<p><em>Caption: Enabling Docker MCP Toolkit under Docker Desktop\u00a0<\/em><\/p>\n<p>Add Required MCP Servers from Catalog<br \/>Add Arm, Sequential Thinking and GitHub Official by following the links below, or by selecting \u201cCatalog\u201d in the Docker Desktop MCP toolkit:<\/p>\n<ul class=\"wp-block-list\">\n<li><a href=\"https:\/\/hub.docker.com\/mcp\/server\/arm-mcp\/overview\" rel=\"nofollow noopener\" target=\"_blank\"><strong>Arm MCP Server<\/strong><\/a> \u2013 Arm migration tools and architecture expertise<\/li>\n<li><a href=\"https:\/\/hub.docker.com\/mcp\/server\/github-official\/overview\" rel=\"nofollow noopener\" target=\"_blank\"><strong>GitHub MCP Server<\/strong><\/a> \u2013 Repository operations and pull request management<\/li>\n<li><a href=\"https:\/\/hub.docker.com\/mcp\/server\/sequentialthinking\/overview\" rel=\"nofollow noopener\" target=\"_blank\"><strong>Sequential Thinking MCP Server<\/strong><\/a> \u2013 Complex problem decomposition and planning<\/li>\n<\/ul>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=880714592  fetchpriority=\"high\" decoding=\"async\" width=\"1056\" height=\"441\" src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image11.png\" class=\"fade-in attachment-full size-full\" alt=\"Searching for Arm MCP Server in the Docker MCP Catalog\" title=\"- image11\" \/>\n        <\/div>\n<p><em>Caption: Searching for Arm MCP Server in the Docker MCP Catalog<\/em><\/p>\n<h3 class=\"wp-block-heading\">Step 2. Configure the Servers<\/h3>\n<ol class=\"wp-block-list\">\n<li><strong>Configure the Arm MCP Server<\/strong><\/li>\n<\/ol>\n<p>To access your local code for the migrate-ease scan and MCA tools, the Arm MCP Server needs a directory configured to point to your local code.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1506727120  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image6.png\"  decoding=\"async\" width=\"1089\" height=\"478\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Arm MCP Server configuration\" title=\"- image6\" \/>\n        <\/div>\n<p><em>Caption: Arm MCP Server configuration<\/em><\/p>\n<p>Once you click \u2018Save\u2019, the Arm MCP Server will know where to look for your code. If you want to give a different directory access in the future, you\u2019ll need to change this path.<\/p>\n<p><strong>Available Arm Migration Tools<\/strong><\/p>\n<p>Click Tools to view all the six MCP tools available under Arm MCP Server.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=281632075  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image16.png\"  decoding=\"async\" width=\"1193\" height=\"859\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"List of MCP tools provided by the Arm MCP Server\" title=\"- image16\" \/>\n        <\/div>\n<p><em>Caption: List of MCP tools provided by the Arm MCP Server<\/em><\/p>\n<ul class=\"wp-block-list\">\n<li><code>knowledge_base_search<\/code> \u2013 Semantic search of Arm learning resources, intrinsics documentation, and software compatibility<\/li>\n<li><code>migrate_ease_scan<\/code> \u2013 Code scanner supporting C++, Python, Go, JavaScript, and Java for Arm compatibility analysis<\/li>\n<li><code>check_image<\/code> \u2013 Docker image architecture verification (checks if images support ARM64)<\/li>\n<li><code>skopeo<\/code> \u2013 Remote container image inspection without downloading<\/li>\n<li><code>mca<\/code> \u2013 Machine Code Analyzer for assembly performance analysis and IPC predictions<\/li>\n<li><code>sysreport_instructions<\/code> \u2013 System architecture information gathering<\/li>\n<\/ul>\n<ol start=\"2\" class=\"wp-block-list\">\n<li><strong>Configure GitHub MCP Server<\/strong><\/li>\n<\/ol>\n<p>The GitHub MCP Server lets GitHub Copilot create pull requests, manage issues, and commit changes.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=163569813  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image13.png\"  decoding=\"async\" width=\"1205\" height=\"394\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Steps to configure GitHub Official MCP Server\" title=\"- image13\" \/>\n        <\/div>\n<p><em>Caption: Steps to configure GitHub Official MCP Server<\/em><\/p>\n<p><strong>Configure Authentication:<\/strong><\/p>\n<ol class=\"wp-block-list\">\n<li>Select GitHub official<\/li>\n<li>Choose your preferred authentication method\u00a0<\/li>\n<li>For Personal Access Token, you\u2019ll need to get the token from GitHub &gt; Settings &gt; Developer Settings<\/li>\n<\/ol>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1530734306  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image5-1.png\"  decoding=\"async\" width=\"1999\" height=\"483\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Setting up Personal Access Token in GitHub MCP Server\" title=\"- image5 1\" \/>\n        <\/div>\n<p><em>Caption: Setting up Personal Access Token in GitHub MCP Server<\/em><\/p>\n<ol start=\"3\" class=\"wp-block-list\">\n<li><strong>Configure Sequential Thinking MCP Server<\/strong><\/li>\n<\/ol>\n<ul class=\"wp-block-list\">\n<li>Click <strong>\u201cSequential Thinking\u201d<\/strong><\/li>\n<li>No configuration needed<\/li>\n<\/ul>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1938095355  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image7.png\"  decoding=\"async\" width=\"1999\" height=\"471\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Sequential MCP Server requires zero configuration\" title=\"- image7\" \/>\n        <\/div>\n<p><em>Caption: Sequential MCP Server requires zero configuration<\/em><\/p>\n<p>This server helps GitHub Copilot break down complex Arm migration decisions into logical steps.<\/p>\n<h3 class=\"wp-block-heading\"><strong>Step 3. Add the Servers to VS Code<\/strong><\/h3>\n<p>The Docker MCP Toolkit makes it incredibly easy to configure MCP servers for clients like VS Code.<\/p>\n<p>To configure, click \u201cClients\u201d and scroll down to Visual Studio Code. Click the \u201cConnect\u201d button:<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=687873174  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image3-1.png\"  decoding=\"async\" width=\"1256\" height=\"130\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"MCP Toolkit clients\" title=\"- image3 1\" \/>\n        <\/div>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1051615372  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image9.png\"  decoding=\"async\" width=\"1254\" height=\"96\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Setting up Visual Studio Code as MCP Client\" title=\"- image9\" \/>\n        <\/div>\n<p><em>Caption: Setting up Visual Studio Code as MCP Client<\/em><\/p>\n<p>Now open VS Code and click on the \u2018Extensions\u2019 icon in the left toolbar:<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1710201605  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image2-1.png\"  decoding=\"async\" width=\"290\" height=\"1006\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Configuring MCP_DOCKER under VS Code Extensions\" title=\"- image2 1\" \/>\n        <\/div>\n<p><em>Caption: Configuring MCP_DOCKER under VS Code Extensions<\/em><\/p>\n<p>Click the <code>MCP_DOCKER<\/code> gear, and click \u2018Start Server\u2019:<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=952586330  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image10.png\"  decoding=\"async\" width=\"442\" height=\"195\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Starting MCP Server under VS Code\" title=\"- image10\" \/>\n        <\/div>\n<p><em>Caption: Starting MCP Server under VS Code<\/em><\/p>\n<p>Now you\u2019re ready to perform an Arm migration!<\/p>\n<h3 class=\"wp-block-heading\"><strong>Step 4. Verify Connection<\/strong><\/h3>\n<p>Open GitHub Copilot Chat in VS Code and ask:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\nWhat Arm migration tools do you have access to?\n<\/pre>\n<\/div>\n<p>You should see tools from all three servers listed. If you see them, your connection works. Let\u2019s migrate some code.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1123350832  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image8.png\"  decoding=\"async\" width=\"1999\" height=\"1115\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Playing around with GitHub Co-Pilot\" title=\"- image8\" \/>\n        <\/div>\n<p><em>Caption: Playing around with GitHub Co-Pilot<\/em><\/p>\n<h2 class=\"wp-block-heading\"><strong>Real-World Demo: Migrating a Legacy x86 Application<\/strong><\/h2>\n<p>Now that you\u2019ve connected GitHub Copilot to Docker MCP Toolkit, let\u2019s migrate that matrix multiplication benchmark we looked at earlier.<\/p>\n<p><strong>Time to migrate<\/strong>: 20 minutes<br \/><strong>Infrastructure<\/strong>: $0 (all runs in Docker containers)<br \/><strong>Prerequisites<\/strong>: The code we showed earlier in this post<\/p>\n<h3 class=\"wp-block-heading\"><strong>The Workflow<\/strong><\/h3>\n<p>Docker MCP Toolkit orchestrates the migration through a secure MCP Gateway that routes requests to specialized tools: the Arm MCP Server scans code and converts intrinsics, GitHub MCP Server creates pull requests, and Sequential Thinking plans multi-step migrations. Each tool runs in an isolated Docker container: secure, reproducible, and under your control.<\/p>\n<h3 class=\"wp-block-heading\">Step 1. Clone the repo<\/h3>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\ngit clone https:\/\/github.com\/JoeStech\/docker-blog-arm-migration \n<\/pre>\n<\/div>\n<p><strong>Give GitHub Copilot Migration Instructions<\/strong><\/p>\n<p>Open your project in VS Code. In GitHub Copilot Chat, paste this prompt:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\nYour goal is to migrate this codebase from x86 to ARM64. Use the Arm MCP Server tools to help you with this migration.\n\nSteps to follow:\n1. Check all Dockerfiles - use check_image and\/or skopeo tools to verify Arm compatibility, changing the base image if necessary\n2. Scan the codebase - run migrate_ease_scan with the appropriate language scanner and apply the suggested changes\n3. Use knowledge_base_search when you need Arm architecture guidance or intrinsic equivalents\n4. Update compiler flags and dependencies for ARM64 compatibility\n5. **Create a pull request with all changes using GitHub MCP Server**\n\nImportant notes:\n- Your current working directory is mapped to \/workspace on the MCP server\n- NEON lane indices must be compile-time constants, not variables\n- If you're unsure about Arm equivalents, use knowledge_base_search to find documentation\n- Be sure to find out from the user or system what the target machine is, and use the appropriate intrinsics. For instance, if neoverse (Graviton, Axion, Cobalt) is targeted, use the latest SME\/SME2.\n\n\n**After completing the migration:**\n- Create a pull request with a detailed description of changes\n- Include performance predictions and cost savings in the PR description\n- List all tools used and validation steps needed\n\n<\/pre>\n<\/div>\n<h3 class=\"wp-block-heading\">Step 2. Watch Docker MCP Toolkit Execute<\/h3>\n<p>GitHub Copilot orchestrates the migration using Docker MCP Toolkit. Here\u2019s what happens:<\/p>\n<h4 class=\"wp-block-heading\">Phase 1: Image Analysis<\/h4>\n<p>GitHub Copilot starts by analyzing the Dockerfile\u2019s base image using the Arm MCP Server\u2019s <code>skopeo<\/code> tool.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=21951361  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image1.png\"  decoding=\"async\" width=\"788\" height=\"405\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"GitHub Copilot uses the skopeo tool from the Arm MCP Server to analyze the centos:6 base image\" title=\"- image1\" \/>\n        <\/div>\n<p><em>Caption: GitHub Copilot uses the skopeo tool from the Arm MCP Server to analyze the centos:6 base image. The tool reports that this image\u00a0has no arm64 build available. This is the first blocker identified \u2013 the container won\u2019t even start on Arm hardware.<\/em><\/p>\n<p>This immediately identifies that CentOS 6 has no ARM64 builds and must be replaced.<\/p>\n<h4 class=\"wp-block-heading\">Phase 2: Code Analysis<\/h4>\n<p>Next, Copilot runs the <code>migrate_ease_scan<\/code> tool with the C++ scanner on the codebase.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1795365451  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image12.png\"  decoding=\"async\" width=\"922\" height=\"122\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"The migrate_ease_scan tool analyzes the C++ source code\" title=\"- image12\" \/>\n        <\/div>\n<p><em>Caption: The migrate_ease_scan tool analyzes the C++ source code and detects AVX2 intrinsics, the -mavx2 compiler flag, and x86-specific headers. This automated scan identifies all architecture-dependent code that requires conversion \u2013 work that could take hours to find manually.<\/em><\/p>\n<p>The scan results show exactly what needs to change for Arm compatibility. Each detected issue includes the file location, line number, and specific code that requires modification. This precision eliminates guesswork and ensures nothing is missed.<\/p>\n<h4 class=\"wp-block-heading\">Phase 3: Arm Optimization and Best Practices<\/h4>\n<p>Forx86 intrinsics found in Phase 2, Copilot queries the Arm MCP Server\u2019s knowledge base for Arm equivalents, if needed. It then makes replacements as necessary.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1638171294  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image4-1.png\"  decoding=\"async\" width=\"787\" height=\"538\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"GitHub Copilot uses the knowledge_base_search tool to find ARM NEON equivalents for each AVX2 intrinsic\" title=\"- image4 1\" \/>\n        <\/div>\n<p><em>Caption: GitHub Copilot uses the knowledge_base_search tool to find Arm NEON equivalents for each AVX2 intrinsic.<\/em><\/p>\n<p>The tool returns official Arm documentation showing the conversions: <code>_mm256_loadu_pd()<\/code> becomes <code>vld1q_f64()<\/code>, <code>_mm256_add_pd()<\/code> becomes <code>vaddq_f64()<\/code>, and so on. This knowledge comes from learn.arm.com learning paths and intrinsic documentation.<\/p>\n<p>The knowledge base provides not just the conversion mappings, but also architectural context: AVX2\u2019s 256-bit vectors vs NEON\u2019s 128-bit vectors, which means loop adjustments are needed. Copilot uses this information to rewrite the matrix multiplication code correctly.<\/p>\n<h4 class=\"wp-block-heading\">Phase 4: Create the GitHub PR and Summarize<\/h4>\n<p>After completing the migration, Copilot creates a PR in GitHub and summarizes the changes made.<\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1704755623  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image17.png\"  decoding=\"async\" width=\"793\" height=\"671\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Copilot PR in GitHub\" title=\"- image17\" \/>\n        <\/div>\n<p>The changes are substantial:\u00a0<\/p>\n<ul class=\"wp-block-list\">\n<li><strong>Replaced centos:6 \u2192 ubuntu:22.04, added TARGETARCH for multi-arch builds<\/strong><\/li>\n<li><strong>Added ARM64 detection and -march=armv8-a+simd compiler flag<\/strong><\/li>\n<li><strong>Converted AVX2 \u2192 NEON intrinsics with architecture guards<\/strong><\/li>\n<\/ul>\n<p>The build is now simpler, modern, and Arm-compatible.<\/p>\n<h4 class=\"wp-block-heading\">Phase 5: Checking the Pull Request<\/h4>\n<p>You can verify the Pull Request by visiting <a href=\"https:\/\/github.com\/JoeStech\/docker-blog-arm-migration\/pull\/1\/\" rel=\"nofollow noopener\" target=\"_blank\">https:\/\/github.com\/JoeStech\/docker-blog-arm-migration\/pull\/1\/<\/a><\/p>\n<div class=\"wp-block-ponyo-image\">\n                <img data-opt-id=1678768068  data-opt-src=\"https:\/\/www.docker.com\/app\/uploads\/2026\/01\/image14.png\"  decoding=\"async\" width=\"1251\" height=\"960\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" class=\"fade-in attachment-full size-full\" alt=\"Verifying final Copilot created GitHub PR\" title=\"- image14\" \/>\n        <\/div>\n\n<p>To verify performance, you can build and run the benchmark:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\ndocker buildx build --platform linux\/arm64 -t benchmark:arm64 . --load\n\ndocker run --rm benchmark:arm64\n<\/pre>\n<\/div>\n<p>Which should output:<\/p>\n<div class=\"wp-block-syntaxhighlighter-code \">\n<pre class=\"brush: bash; gutter: false; title: ; notranslate\">\nSIMD Matrix Operations Benchmark\n================================\nRunning on ARM64 architecture with NEON optimizations\n=== Matrix Multiplication Benchmark ===\nMatrix size: 200x200\nTime: 17 ms\nResult sum: 1.98888e+08\n<\/pre>\n<\/div>\n<h3 class=\"wp-block-heading\">Caveats<\/h3>\n<p>A very important thing to remember is that not all models will provide equal results, and while the Arm MCP Server provides deterministic context, the models themselves are stochastic. Always use a flagship latest-generation model to get the best results, and test any guesses the model makes regarding performance improvement.<\/p>\n<h2 class=\"wp-block-heading\">How Docker MCP Toolkit Changes Development<\/h2>\n<p>Docker MCP Toolkit changes how developers interact with specialized knowledge and capabilities. Rather than learning new tools, installing dependencies, or managing credentials, developers connect their AI assistant once and immediately access containerized expertise.<\/p>\n<p>The benefits extend beyond Arm migration:<\/p>\n<ul class=\"wp-block-list\">\n<li><strong>Consistency<\/strong> \u2013 Same tools, same results across all developers<\/li>\n<li><strong>Security<\/strong> \u2013 Containerized isolation prevents tool interference<\/li>\n<li><strong>Version Control<\/strong> \u2013 MCP server versions tracked with application code<\/li>\n<li><strong>Reproducibility<\/strong> \u2013 Migrations behave identically across environments<\/li>\n<li><strong>Discoverability<\/strong> \u2013 Docker MCP Catalog makes finding the right server straightforward<\/li>\n<\/ul>\n<p>Most importantly, developers remain in their existing workflow. VS Code. GitHub Copilot. Git. No context switching to external tools or dashboards.<\/p>\n<h2 class=\"wp-block-heading\">Wrapping Up<\/h2>\n<p>You\u2019ve just automated ARM64 migration using Docker MCP Toolkit, the Arm MCP Server, and GitHub Copilot. What used to require architecture expertise, manual intrinsic conversion, and hours of debugging now happens through natural conversation, safely executed in Docker containers.<\/p>\n<p><strong>Ready to try it?<\/strong> Open <a href=\"https:\/\/hub.docker.com\/open-desktop?url=https:\/\/open.docker.com\/dashboard\/mcp&amp;_gl\" rel=\"nofollow noopener\" target=\"_blank\">Docker Desktop<\/a> and explore the MCP Catalog. Start with the <a href=\"https:\/\/hub.docker.com\/mcp\/server\/arm-mcp\/overview\" rel=\"nofollow noopener\" target=\"_blank\">Arm MCP Server<\/a>, add <a href=\"https:\/\/hub.docker.com\/mcp\/server\/github-official\/overview\" rel=\"nofollow noopener\" target=\"_blank\">GitHub<\/a>, experiment with <a href=\"https:\/\/hub.docker.com\/mcp\/server\/sequentialthinking\/overview\" rel=\"nofollow noopener\" target=\"_blank\">Sequential Thinking<\/a>. Each server unlocks new capabilities.<\/p>\n<p>The future of migration isn\u2019t manually porting every application. It\u2019s having an AI assistant that can execute tasks across your entire stack securely, reproducibly, and at the speed of thought.<\/p>\n<h3 class=\"wp-block-heading\"><strong>Learn More<\/strong><\/h3>\n<ul class=\"wp-block-list\">\n<li><strong>New to Docker?<\/strong><a href=\"https:\/\/www.docker.com\/products\/docker-desktop\"> Download Docker Desktop<\/a><\/li>\n<li><strong>Explore the MCP Catalog:<\/strong><a href=\"https:\/\/hub.docker.com\/mcp\" rel=\"nofollow noopener\" target=\"_blank\"> Discover containerized, security-hardened MCP servers<\/a><\/li>\n<li><strong>Get Started with MCP Toolkit:<\/strong><a href=\"https:\/\/docs.docker.com\/ai\/mcp-catalog-and-toolkit\/\" rel=\"nofollow noopener\" target=\"_blank\"> Official Documentation<\/a><\/li>\n<\/ul>","protected":false},"excerpt":{"rendered":"<p>This post is a collaboration between Docker and Arm, demonstrating how Docker MCP Toolkit and the Arm MCP Server work [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":3297,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[4],"tags":[],"class_list":["post-3296","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-docker"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/3296","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=3296"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/3296\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media\/3297"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=3296"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=3296"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=3296"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}